1 | // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
2 | /* |
3 | * Copyright(c) 2015-2018 Intel Corporation. |
4 | */ |
5 | |
6 | #include <linux/debugfs.h> |
7 | #include <linux/seq_file.h> |
8 | #include <linux/kernel.h> |
9 | #include <linux/export.h> |
10 | #include <linux/string.h> |
11 | #include <linux/types.h> |
12 | #include <linux/ratelimit.h> |
13 | #include <linux/fault-inject.h> |
14 | |
15 | #include "hfi.h" |
16 | #include "trace.h" |
17 | #include "debugfs.h" |
18 | #include "device.h" |
19 | #include "qp.h" |
20 | #include "sdma.h" |
21 | #include "fault.h" |
22 | |
23 | static struct dentry *hfi1_dbg_root; |
24 | |
25 | /* wrappers to enforce srcu in seq file */ |
26 | ssize_t hfi1_seq_read(struct file *file, char __user *buf, size_t size, |
27 | loff_t *ppos) |
28 | { |
29 | struct dentry *d = file->f_path.dentry; |
30 | ssize_t r; |
31 | |
32 | r = debugfs_file_get(dentry: d); |
33 | if (unlikely(r)) |
34 | return r; |
35 | r = seq_read(file, buf, size, ppos); |
36 | debugfs_file_put(dentry: d); |
37 | return r; |
38 | } |
39 | |
40 | loff_t hfi1_seq_lseek(struct file *file, loff_t offset, int whence) |
41 | { |
42 | struct dentry *d = file->f_path.dentry; |
43 | loff_t r; |
44 | |
45 | r = debugfs_file_get(dentry: d); |
46 | if (unlikely(r)) |
47 | return r; |
48 | r = seq_lseek(file, offset, whence); |
49 | debugfs_file_put(dentry: d); |
50 | return r; |
51 | } |
52 | |
53 | #define private2dd(file) (file_inode(file)->i_private) |
54 | #define private2ppd(file) (file_inode(file)->i_private) |
55 | |
56 | static void *_opcode_stats_seq_start(struct seq_file *s, loff_t *pos) |
57 | { |
58 | struct hfi1_opcode_stats_perctx *opstats; |
59 | |
60 | if (*pos >= ARRAY_SIZE(opstats->stats)) |
61 | return NULL; |
62 | return pos; |
63 | } |
64 | |
65 | static void *_opcode_stats_seq_next(struct seq_file *s, void *v, loff_t *pos) |
66 | { |
67 | struct hfi1_opcode_stats_perctx *opstats; |
68 | |
69 | ++*pos; |
70 | if (*pos >= ARRAY_SIZE(opstats->stats)) |
71 | return NULL; |
72 | return pos; |
73 | } |
74 | |
75 | static void _opcode_stats_seq_stop(struct seq_file *s, void *v) |
76 | { |
77 | } |
78 | |
79 | static int opcode_stats_show(struct seq_file *s, u8 i, u64 packets, u64 bytes) |
80 | { |
81 | if (!packets && !bytes) |
82 | return SEQ_SKIP; |
83 | seq_printf(m: s, fmt: "%02x %llu/%llu\n" , i, |
84 | (unsigned long long)packets, |
85 | (unsigned long long)bytes); |
86 | |
87 | return 0; |
88 | } |
89 | |
90 | static int _opcode_stats_seq_show(struct seq_file *s, void *v) |
91 | { |
92 | loff_t *spos = v; |
93 | loff_t i = *spos, j; |
94 | u64 n_packets = 0, n_bytes = 0; |
95 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
96 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
97 | struct hfi1_ctxtdata *rcd; |
98 | |
99 | for (j = 0; j < dd->first_dyn_alloc_ctxt; j++) { |
100 | rcd = hfi1_rcd_get_by_index(dd, ctxt: j); |
101 | if (rcd) { |
102 | n_packets += rcd->opstats->stats[i].n_packets; |
103 | n_bytes += rcd->opstats->stats[i].n_bytes; |
104 | } |
105 | hfi1_rcd_put(rcd); |
106 | } |
107 | return opcode_stats_show(s, i, packets: n_packets, bytes: n_bytes); |
108 | } |
109 | |
110 | DEBUGFS_SEQ_FILE_OPS(opcode_stats); |
111 | DEBUGFS_SEQ_FILE_OPEN(opcode_stats) |
112 | DEBUGFS_FILE_OPS(opcode_stats); |
113 | |
114 | static void *_tx_opcode_stats_seq_start(struct seq_file *s, loff_t *pos) |
115 | { |
116 | return _opcode_stats_seq_start(s, pos); |
117 | } |
118 | |
119 | static void *_tx_opcode_stats_seq_next(struct seq_file *s, void *v, loff_t *pos) |
120 | { |
121 | return _opcode_stats_seq_next(s, v, pos); |
122 | } |
123 | |
124 | static void _tx_opcode_stats_seq_stop(struct seq_file *s, void *v) |
125 | { |
126 | } |
127 | |
128 | static int _tx_opcode_stats_seq_show(struct seq_file *s, void *v) |
129 | { |
130 | loff_t *spos = v; |
131 | loff_t i = *spos; |
132 | int j; |
133 | u64 n_packets = 0, n_bytes = 0; |
134 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
135 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
136 | |
137 | for_each_possible_cpu(j) { |
138 | struct hfi1_opcode_stats_perctx *s = |
139 | per_cpu_ptr(dd->tx_opstats, j); |
140 | n_packets += s->stats[i].n_packets; |
141 | n_bytes += s->stats[i].n_bytes; |
142 | } |
143 | return opcode_stats_show(s, i, packets: n_packets, bytes: n_bytes); |
144 | } |
145 | |
146 | DEBUGFS_SEQ_FILE_OPS(tx_opcode_stats); |
147 | DEBUGFS_SEQ_FILE_OPEN(tx_opcode_stats) |
148 | DEBUGFS_FILE_OPS(tx_opcode_stats); |
149 | |
150 | static void *_ctx_stats_seq_start(struct seq_file *s, loff_t *pos) |
151 | { |
152 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
153 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
154 | |
155 | if (!*pos) |
156 | return SEQ_START_TOKEN; |
157 | if (*pos >= dd->first_dyn_alloc_ctxt) |
158 | return NULL; |
159 | return pos; |
160 | } |
161 | |
162 | static void *_ctx_stats_seq_next(struct seq_file *s, void *v, loff_t *pos) |
163 | { |
164 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
165 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
166 | |
167 | if (v == SEQ_START_TOKEN) |
168 | return pos; |
169 | |
170 | ++*pos; |
171 | if (*pos >= dd->first_dyn_alloc_ctxt) |
172 | return NULL; |
173 | return pos; |
174 | } |
175 | |
176 | static void _ctx_stats_seq_stop(struct seq_file *s, void *v) |
177 | { |
178 | /* nothing allocated */ |
179 | } |
180 | |
181 | static int _ctx_stats_seq_show(struct seq_file *s, void *v) |
182 | { |
183 | loff_t *spos; |
184 | loff_t i, j; |
185 | u64 n_packets = 0; |
186 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
187 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
188 | struct hfi1_ctxtdata *rcd; |
189 | |
190 | if (v == SEQ_START_TOKEN) { |
191 | seq_puts(m: s, s: "Ctx:npkts\n" ); |
192 | return 0; |
193 | } |
194 | |
195 | spos = v; |
196 | i = *spos; |
197 | |
198 | rcd = hfi1_rcd_get_by_index_safe(dd, ctxt: i); |
199 | if (!rcd) |
200 | return SEQ_SKIP; |
201 | |
202 | for (j = 0; j < ARRAY_SIZE(rcd->opstats->stats); j++) |
203 | n_packets += rcd->opstats->stats[j].n_packets; |
204 | |
205 | hfi1_rcd_put(rcd); |
206 | |
207 | if (!n_packets) |
208 | return SEQ_SKIP; |
209 | |
210 | seq_printf(m: s, fmt: " %llu:%llu\n" , i, n_packets); |
211 | return 0; |
212 | } |
213 | |
214 | DEBUGFS_SEQ_FILE_OPS(ctx_stats); |
215 | DEBUGFS_SEQ_FILE_OPEN(ctx_stats) |
216 | DEBUGFS_FILE_OPS(ctx_stats); |
217 | |
218 | static void *_qp_stats_seq_start(struct seq_file *s, loff_t *pos) |
219 | __acquires(RCU) |
220 | { |
221 | struct rvt_qp_iter *iter; |
222 | loff_t n = *pos; |
223 | |
224 | iter = rvt_qp_iter_init(rdi: s->private, v: 0, NULL); |
225 | |
226 | /* stop calls rcu_read_unlock */ |
227 | rcu_read_lock(); |
228 | |
229 | if (!iter) |
230 | return NULL; |
231 | |
232 | do { |
233 | if (rvt_qp_iter_next(iter)) { |
234 | kfree(objp: iter); |
235 | return NULL; |
236 | } |
237 | } while (n--); |
238 | |
239 | return iter; |
240 | } |
241 | |
242 | static void *_qp_stats_seq_next(struct seq_file *s, void *iter_ptr, |
243 | loff_t *pos) |
244 | __must_hold(RCU) |
245 | { |
246 | struct rvt_qp_iter *iter = iter_ptr; |
247 | |
248 | (*pos)++; |
249 | |
250 | if (rvt_qp_iter_next(iter)) { |
251 | kfree(objp: iter); |
252 | return NULL; |
253 | } |
254 | |
255 | return iter; |
256 | } |
257 | |
258 | static void _qp_stats_seq_stop(struct seq_file *s, void *iter_ptr) |
259 | __releases(RCU) |
260 | { |
261 | rcu_read_unlock(); |
262 | } |
263 | |
264 | static int _qp_stats_seq_show(struct seq_file *s, void *iter_ptr) |
265 | { |
266 | struct rvt_qp_iter *iter = iter_ptr; |
267 | |
268 | if (!iter) |
269 | return 0; |
270 | |
271 | qp_iter_print(s, iter); |
272 | |
273 | return 0; |
274 | } |
275 | |
276 | DEBUGFS_SEQ_FILE_OPS(qp_stats); |
277 | DEBUGFS_SEQ_FILE_OPEN(qp_stats) |
278 | DEBUGFS_FILE_OPS(qp_stats); |
279 | |
280 | static void *_sdes_seq_start(struct seq_file *s, loff_t *pos) |
281 | { |
282 | struct hfi1_ibdev *ibd; |
283 | struct hfi1_devdata *dd; |
284 | |
285 | ibd = (struct hfi1_ibdev *)s->private; |
286 | dd = dd_from_dev(dev: ibd); |
287 | if (!dd->per_sdma || *pos >= dd->num_sdma) |
288 | return NULL; |
289 | return pos; |
290 | } |
291 | |
292 | static void *_sdes_seq_next(struct seq_file *s, void *v, loff_t *pos) |
293 | { |
294 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
295 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
296 | |
297 | ++*pos; |
298 | if (!dd->per_sdma || *pos >= dd->num_sdma) |
299 | return NULL; |
300 | return pos; |
301 | } |
302 | |
303 | static void _sdes_seq_stop(struct seq_file *s, void *v) |
304 | { |
305 | } |
306 | |
307 | static int _sdes_seq_show(struct seq_file *s, void *v) |
308 | { |
309 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
310 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
311 | loff_t *spos = v; |
312 | loff_t i = *spos; |
313 | |
314 | sdma_seqfile_dump_sde(s, &dd->per_sdma[i]); |
315 | return 0; |
316 | } |
317 | |
318 | DEBUGFS_SEQ_FILE_OPS(sdes); |
319 | DEBUGFS_SEQ_FILE_OPEN(sdes) |
320 | DEBUGFS_FILE_OPS(sdes); |
321 | |
322 | static void *_rcds_seq_start(struct seq_file *s, loff_t *pos) |
323 | { |
324 | struct hfi1_ibdev *ibd; |
325 | struct hfi1_devdata *dd; |
326 | |
327 | ibd = (struct hfi1_ibdev *)s->private; |
328 | dd = dd_from_dev(dev: ibd); |
329 | if (!dd->rcd || *pos >= dd->n_krcv_queues) |
330 | return NULL; |
331 | return pos; |
332 | } |
333 | |
334 | static void *_rcds_seq_next(struct seq_file *s, void *v, loff_t *pos) |
335 | { |
336 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
337 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
338 | |
339 | ++*pos; |
340 | if (!dd->rcd || *pos >= dd->num_rcv_contexts) |
341 | return NULL; |
342 | return pos; |
343 | } |
344 | |
345 | static void _rcds_seq_stop(struct seq_file *s, void *v) |
346 | { |
347 | } |
348 | |
349 | static int _rcds_seq_show(struct seq_file *s, void *v) |
350 | { |
351 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
352 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
353 | struct hfi1_ctxtdata *rcd; |
354 | loff_t *spos = v; |
355 | loff_t i = *spos; |
356 | |
357 | rcd = hfi1_rcd_get_by_index_safe(dd, ctxt: i); |
358 | if (rcd) |
359 | seqfile_dump_rcd(s, rcd); |
360 | hfi1_rcd_put(rcd); |
361 | return 0; |
362 | } |
363 | |
364 | DEBUGFS_SEQ_FILE_OPS(rcds); |
365 | DEBUGFS_SEQ_FILE_OPEN(rcds) |
366 | DEBUGFS_FILE_OPS(rcds); |
367 | |
368 | static void *_pios_seq_start(struct seq_file *s, loff_t *pos) |
369 | { |
370 | struct hfi1_ibdev *ibd; |
371 | struct hfi1_devdata *dd; |
372 | |
373 | ibd = (struct hfi1_ibdev *)s->private; |
374 | dd = dd_from_dev(dev: ibd); |
375 | if (!dd->send_contexts || *pos >= dd->num_send_contexts) |
376 | return NULL; |
377 | return pos; |
378 | } |
379 | |
380 | static void *_pios_seq_next(struct seq_file *s, void *v, loff_t *pos) |
381 | { |
382 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
383 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
384 | |
385 | ++*pos; |
386 | if (!dd->send_contexts || *pos >= dd->num_send_contexts) |
387 | return NULL; |
388 | return pos; |
389 | } |
390 | |
391 | static void _pios_seq_stop(struct seq_file *s, void *v) |
392 | { |
393 | } |
394 | |
395 | static int _pios_seq_show(struct seq_file *s, void *v) |
396 | { |
397 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
398 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
399 | struct send_context_info *sci; |
400 | loff_t *spos = v; |
401 | loff_t i = *spos; |
402 | unsigned long flags; |
403 | |
404 | spin_lock_irqsave(&dd->sc_lock, flags); |
405 | sci = &dd->send_contexts[i]; |
406 | if (sci && sci->type != SC_USER && sci->allocated && sci->sc) |
407 | seqfile_dump_sci(s, i, sci); |
408 | spin_unlock_irqrestore(lock: &dd->sc_lock, flags); |
409 | return 0; |
410 | } |
411 | |
412 | DEBUGFS_SEQ_FILE_OPS(pios); |
413 | DEBUGFS_SEQ_FILE_OPEN(pios) |
414 | DEBUGFS_FILE_OPS(pios); |
415 | |
416 | /* read the per-device counters */ |
417 | static ssize_t dev_counters_read(struct file *file, char __user *buf, |
418 | size_t count, loff_t *ppos) |
419 | { |
420 | u64 *counters; |
421 | size_t avail; |
422 | struct hfi1_devdata *dd; |
423 | ssize_t rval; |
424 | |
425 | dd = private2dd(file); |
426 | avail = hfi1_read_cntrs(dd, NULL, cntrp: &counters); |
427 | rval = simple_read_from_buffer(to: buf, count, ppos, from: counters, available: avail); |
428 | return rval; |
429 | } |
430 | |
431 | /* read the per-device counters */ |
432 | static ssize_t dev_names_read(struct file *file, char __user *buf, |
433 | size_t count, loff_t *ppos) |
434 | { |
435 | char *names; |
436 | size_t avail; |
437 | struct hfi1_devdata *dd; |
438 | ssize_t rval; |
439 | |
440 | dd = private2dd(file); |
441 | avail = hfi1_read_cntrs(dd, namep: &names, NULL); |
442 | rval = simple_read_from_buffer(to: buf, count, ppos, from: names, available: avail); |
443 | return rval; |
444 | } |
445 | |
446 | struct counter_info { |
447 | char *name; |
448 | const struct file_operations ops; |
449 | }; |
450 | |
451 | /* |
452 | * Could use file_inode(file)->i_ino to figure out which file, |
453 | * instead of separate routine for each, but for now, this works... |
454 | */ |
455 | |
456 | /* read the per-port names (same for each port) */ |
457 | static ssize_t portnames_read(struct file *file, char __user *buf, |
458 | size_t count, loff_t *ppos) |
459 | { |
460 | char *names; |
461 | size_t avail; |
462 | struct hfi1_devdata *dd; |
463 | ssize_t rval; |
464 | |
465 | dd = private2dd(file); |
466 | avail = hfi1_read_portcntrs(ppd: dd->pport, namep: &names, NULL); |
467 | rval = simple_read_from_buffer(to: buf, count, ppos, from: names, available: avail); |
468 | return rval; |
469 | } |
470 | |
471 | /* read the per-port counters */ |
472 | static ssize_t portcntrs_debugfs_read(struct file *file, char __user *buf, |
473 | size_t count, loff_t *ppos) |
474 | { |
475 | u64 *counters; |
476 | size_t avail; |
477 | struct hfi1_pportdata *ppd; |
478 | ssize_t rval; |
479 | |
480 | ppd = private2ppd(file); |
481 | avail = hfi1_read_portcntrs(ppd, NULL, cntrp: &counters); |
482 | rval = simple_read_from_buffer(to: buf, count, ppos, from: counters, available: avail); |
483 | return rval; |
484 | } |
485 | |
486 | static void check_dyn_flag(u64 scratch0, char *p, int size, int *used, |
487 | int this_hfi, int hfi, u32 flag, const char *what) |
488 | { |
489 | u32 mask; |
490 | |
491 | mask = flag << (hfi ? CR_DYN_SHIFT : 0); |
492 | if (scratch0 & mask) { |
493 | *used += scnprintf(buf: p + *used, size: size - *used, |
494 | fmt: " 0x%08x - HFI%d %s in use, %s device\n" , |
495 | mask, hfi, what, |
496 | this_hfi == hfi ? "this" : "other" ); |
497 | } |
498 | } |
499 | |
500 | static ssize_t asic_flags_read(struct file *file, char __user *buf, |
501 | size_t count, loff_t *ppos) |
502 | { |
503 | struct hfi1_pportdata *ppd; |
504 | struct hfi1_devdata *dd; |
505 | u64 scratch0; |
506 | char *tmp; |
507 | int ret = 0; |
508 | int size; |
509 | int used; |
510 | int i; |
511 | |
512 | ppd = private2ppd(file); |
513 | dd = ppd->dd; |
514 | size = PAGE_SIZE; |
515 | used = 0; |
516 | tmp = kmalloc(size, GFP_KERNEL); |
517 | if (!tmp) |
518 | return -ENOMEM; |
519 | |
520 | scratch0 = read_csr(dd, ASIC_CFG_SCRATCH); |
521 | used += scnprintf(buf: tmp + used, size: size - used, |
522 | fmt: "Resource flags: 0x%016llx\n" , scratch0); |
523 | |
524 | /* check permanent flag */ |
525 | if (scratch0 & CR_THERM_INIT) { |
526 | used += scnprintf(buf: tmp + used, size: size - used, |
527 | fmt: " 0x%08x - thermal monitoring initialized\n" , |
528 | (u32)CR_THERM_INIT); |
529 | } |
530 | |
531 | /* check each dynamic flag on each HFI */ |
532 | for (i = 0; i < 2; i++) { |
533 | check_dyn_flag(scratch0, p: tmp, size, used: &used, this_hfi: dd->hfi1_id, hfi: i, |
534 | CR_SBUS, what: "SBus" ); |
535 | check_dyn_flag(scratch0, p: tmp, size, used: &used, this_hfi: dd->hfi1_id, hfi: i, |
536 | CR_EPROM, what: "EPROM" ); |
537 | check_dyn_flag(scratch0, p: tmp, size, used: &used, this_hfi: dd->hfi1_id, hfi: i, |
538 | CR_I2C1, what: "i2c chain 1" ); |
539 | check_dyn_flag(scratch0, p: tmp, size, used: &used, this_hfi: dd->hfi1_id, hfi: i, |
540 | CR_I2C2, what: "i2c chain 2" ); |
541 | } |
542 | used += scnprintf(buf: tmp + used, size: size - used, fmt: "Write bits to clear\n" ); |
543 | |
544 | ret = simple_read_from_buffer(to: buf, count, ppos, from: tmp, available: used); |
545 | kfree(objp: tmp); |
546 | return ret; |
547 | } |
548 | |
549 | static ssize_t asic_flags_write(struct file *file, const char __user *buf, |
550 | size_t count, loff_t *ppos) |
551 | { |
552 | struct hfi1_pportdata *ppd; |
553 | struct hfi1_devdata *dd; |
554 | char *buff; |
555 | int ret; |
556 | unsigned long long value; |
557 | u64 scratch0; |
558 | u64 clear; |
559 | |
560 | ppd = private2ppd(file); |
561 | dd = ppd->dd; |
562 | |
563 | /* zero terminate and read the expected integer */ |
564 | buff = memdup_user_nul(buf, count); |
565 | if (IS_ERR(ptr: buff)) |
566 | return PTR_ERR(ptr: buff); |
567 | |
568 | ret = kstrtoull(s: buff, base: 0, res: &value); |
569 | if (ret) |
570 | goto do_free; |
571 | clear = value; |
572 | |
573 | /* obtain exclusive access */ |
574 | mutex_lock(&dd->asic_data->asic_resource_mutex); |
575 | acquire_hw_mutex(dd); |
576 | |
577 | scratch0 = read_csr(dd, ASIC_CFG_SCRATCH); |
578 | scratch0 &= ~clear; |
579 | write_csr(dd, ASIC_CFG_SCRATCH, value: scratch0); |
580 | /* force write to be visible to other HFI on another OS */ |
581 | (void)read_csr(dd, ASIC_CFG_SCRATCH); |
582 | |
583 | release_hw_mutex(dd); |
584 | mutex_unlock(lock: &dd->asic_data->asic_resource_mutex); |
585 | |
586 | /* return the number of bytes written */ |
587 | ret = count; |
588 | |
589 | do_free: |
590 | kfree(objp: buff); |
591 | return ret; |
592 | } |
593 | |
594 | /* read the dc8051 memory */ |
595 | static ssize_t dc8051_memory_read(struct file *file, char __user *buf, |
596 | size_t count, loff_t *ppos) |
597 | { |
598 | struct hfi1_pportdata *ppd = private2ppd(file); |
599 | ssize_t rval; |
600 | void *tmp; |
601 | loff_t start, end; |
602 | |
603 | /* the checks below expect the position to be positive */ |
604 | if (*ppos < 0) |
605 | return -EINVAL; |
606 | |
607 | tmp = kzalloc(DC8051_DATA_MEM_SIZE, GFP_KERNEL); |
608 | if (!tmp) |
609 | return -ENOMEM; |
610 | |
611 | /* |
612 | * Fill in the requested portion of the temporary buffer from the |
613 | * 8051 memory. The 8051 memory read is done in terms of 8 bytes. |
614 | * Adjust start and end to fit. Skip reading anything if out of |
615 | * range. |
616 | */ |
617 | start = *ppos & ~0x7; /* round down */ |
618 | if (start < DC8051_DATA_MEM_SIZE) { |
619 | end = (*ppos + count + 7) & ~0x7; /* round up */ |
620 | if (end > DC8051_DATA_MEM_SIZE) |
621 | end = DC8051_DATA_MEM_SIZE; |
622 | rval = read_8051_data(dd: ppd->dd, addr: start, len: end - start, |
623 | result: (u64 *)(tmp + start)); |
624 | if (rval) |
625 | goto done; |
626 | } |
627 | |
628 | rval = simple_read_from_buffer(to: buf, count, ppos, from: tmp, |
629 | DC8051_DATA_MEM_SIZE); |
630 | done: |
631 | kfree(objp: tmp); |
632 | return rval; |
633 | } |
634 | |
635 | static ssize_t debugfs_lcb_read(struct file *file, char __user *buf, |
636 | size_t count, loff_t *ppos) |
637 | { |
638 | struct hfi1_pportdata *ppd = private2ppd(file); |
639 | struct hfi1_devdata *dd = ppd->dd; |
640 | unsigned long total, csr_off; |
641 | u64 data; |
642 | |
643 | if (*ppos < 0) |
644 | return -EINVAL; |
645 | /* only read 8 byte quantities */ |
646 | if ((count % 8) != 0) |
647 | return -EINVAL; |
648 | /* offset must be 8-byte aligned */ |
649 | if ((*ppos % 8) != 0) |
650 | return -EINVAL; |
651 | /* do nothing if out of range or zero count */ |
652 | if (*ppos >= (LCB_END - LCB_START) || !count) |
653 | return 0; |
654 | /* reduce count if needed */ |
655 | if (*ppos + count > LCB_END - LCB_START) |
656 | count = (LCB_END - LCB_START) - *ppos; |
657 | |
658 | csr_off = LCB_START + *ppos; |
659 | for (total = 0; total < count; total += 8, csr_off += 8) { |
660 | if (read_lcb_csr(dd, offset: csr_off, data: (u64 *)&data)) |
661 | break; /* failed */ |
662 | if (put_user(data, (unsigned long __user *)(buf + total))) |
663 | break; |
664 | } |
665 | *ppos += total; |
666 | return total; |
667 | } |
668 | |
669 | static ssize_t debugfs_lcb_write(struct file *file, const char __user *buf, |
670 | size_t count, loff_t *ppos) |
671 | { |
672 | struct hfi1_pportdata *ppd = private2ppd(file); |
673 | struct hfi1_devdata *dd = ppd->dd; |
674 | unsigned long total, csr_off, data; |
675 | |
676 | if (*ppos < 0) |
677 | return -EINVAL; |
678 | /* only write 8 byte quantities */ |
679 | if ((count % 8) != 0) |
680 | return -EINVAL; |
681 | /* offset must be 8-byte aligned */ |
682 | if ((*ppos % 8) != 0) |
683 | return -EINVAL; |
684 | /* do nothing if out of range or zero count */ |
685 | if (*ppos >= (LCB_END - LCB_START) || !count) |
686 | return 0; |
687 | /* reduce count if needed */ |
688 | if (*ppos + count > LCB_END - LCB_START) |
689 | count = (LCB_END - LCB_START) - *ppos; |
690 | |
691 | csr_off = LCB_START + *ppos; |
692 | for (total = 0; total < count; total += 8, csr_off += 8) { |
693 | if (get_user(data, (unsigned long __user *)(buf + total))) |
694 | break; |
695 | if (write_lcb_csr(dd, offset: csr_off, data)) |
696 | break; /* failed */ |
697 | } |
698 | *ppos += total; |
699 | return total; |
700 | } |
701 | |
702 | /* |
703 | * read the per-port QSFP data for ppd |
704 | */ |
705 | static ssize_t qsfp_debugfs_dump(struct file *file, char __user *buf, |
706 | size_t count, loff_t *ppos) |
707 | { |
708 | struct hfi1_pportdata *ppd; |
709 | char *tmp; |
710 | int ret; |
711 | |
712 | ppd = private2ppd(file); |
713 | tmp = kmalloc(PAGE_SIZE, GFP_KERNEL); |
714 | if (!tmp) |
715 | return -ENOMEM; |
716 | |
717 | ret = qsfp_dump(ppd, buf: tmp, PAGE_SIZE); |
718 | if (ret > 0) |
719 | ret = simple_read_from_buffer(to: buf, count, ppos, from: tmp, available: ret); |
720 | kfree(objp: tmp); |
721 | return ret; |
722 | } |
723 | |
724 | /* Do an i2c write operation on the chain for the given HFI. */ |
725 | static ssize_t __i2c_debugfs_write(struct file *file, const char __user *buf, |
726 | size_t count, loff_t *ppos, u32 target) |
727 | { |
728 | struct hfi1_pportdata *ppd; |
729 | char *buff; |
730 | int ret; |
731 | int i2c_addr; |
732 | int offset; |
733 | int total_written; |
734 | |
735 | ppd = private2ppd(file); |
736 | |
737 | /* byte offset format: [offsetSize][i2cAddr][offsetHigh][offsetLow] */ |
738 | i2c_addr = (*ppos >> 16) & 0xffff; |
739 | offset = *ppos & 0xffff; |
740 | |
741 | /* explicitly reject invalid address 0 to catch cp and cat */ |
742 | if (i2c_addr == 0) |
743 | return -EINVAL; |
744 | |
745 | buff = memdup_user(buf, count); |
746 | if (IS_ERR(ptr: buff)) |
747 | return PTR_ERR(ptr: buff); |
748 | |
749 | total_written = i2c_write(ppd, target, i2c_addr, offset, bp: buff, len: count); |
750 | if (total_written < 0) { |
751 | ret = total_written; |
752 | goto _free; |
753 | } |
754 | |
755 | *ppos += total_written; |
756 | |
757 | ret = total_written; |
758 | |
759 | _free: |
760 | kfree(objp: buff); |
761 | return ret; |
762 | } |
763 | |
764 | /* Do an i2c write operation on chain for HFI 0. */ |
765 | static ssize_t i2c1_debugfs_write(struct file *file, const char __user *buf, |
766 | size_t count, loff_t *ppos) |
767 | { |
768 | return __i2c_debugfs_write(file, buf, count, ppos, target: 0); |
769 | } |
770 | |
771 | /* Do an i2c write operation on chain for HFI 1. */ |
772 | static ssize_t i2c2_debugfs_write(struct file *file, const char __user *buf, |
773 | size_t count, loff_t *ppos) |
774 | { |
775 | return __i2c_debugfs_write(file, buf, count, ppos, target: 1); |
776 | } |
777 | |
778 | /* Do an i2c read operation on the chain for the given HFI. */ |
779 | static ssize_t __i2c_debugfs_read(struct file *file, char __user *buf, |
780 | size_t count, loff_t *ppos, u32 target) |
781 | { |
782 | struct hfi1_pportdata *ppd; |
783 | char *buff; |
784 | int ret; |
785 | int i2c_addr; |
786 | int offset; |
787 | int total_read; |
788 | |
789 | ppd = private2ppd(file); |
790 | |
791 | /* byte offset format: [offsetSize][i2cAddr][offsetHigh][offsetLow] */ |
792 | i2c_addr = (*ppos >> 16) & 0xffff; |
793 | offset = *ppos & 0xffff; |
794 | |
795 | /* explicitly reject invalid address 0 to catch cp and cat */ |
796 | if (i2c_addr == 0) |
797 | return -EINVAL; |
798 | |
799 | buff = kmalloc(size: count, GFP_KERNEL); |
800 | if (!buff) |
801 | return -ENOMEM; |
802 | |
803 | total_read = i2c_read(ppd, target, i2c_addr, offset, bp: buff, len: count); |
804 | if (total_read < 0) { |
805 | ret = total_read; |
806 | goto _free; |
807 | } |
808 | |
809 | *ppos += total_read; |
810 | |
811 | ret = copy_to_user(to: buf, from: buff, n: total_read); |
812 | if (ret > 0) { |
813 | ret = -EFAULT; |
814 | goto _free; |
815 | } |
816 | |
817 | ret = total_read; |
818 | |
819 | _free: |
820 | kfree(objp: buff); |
821 | return ret; |
822 | } |
823 | |
824 | /* Do an i2c read operation on chain for HFI 0. */ |
825 | static ssize_t i2c1_debugfs_read(struct file *file, char __user *buf, |
826 | size_t count, loff_t *ppos) |
827 | { |
828 | return __i2c_debugfs_read(file, buf, count, ppos, target: 0); |
829 | } |
830 | |
831 | /* Do an i2c read operation on chain for HFI 1. */ |
832 | static ssize_t i2c2_debugfs_read(struct file *file, char __user *buf, |
833 | size_t count, loff_t *ppos) |
834 | { |
835 | return __i2c_debugfs_read(file, buf, count, ppos, target: 1); |
836 | } |
837 | |
838 | /* Do a QSFP write operation on the i2c chain for the given HFI. */ |
839 | static ssize_t __qsfp_debugfs_write(struct file *file, const char __user *buf, |
840 | size_t count, loff_t *ppos, u32 target) |
841 | { |
842 | struct hfi1_pportdata *ppd; |
843 | char *buff; |
844 | int ret; |
845 | int total_written; |
846 | |
847 | if (*ppos + count > QSFP_PAGESIZE * 4) /* base page + page00-page03 */ |
848 | return -EINVAL; |
849 | |
850 | ppd = private2ppd(file); |
851 | |
852 | buff = memdup_user(buf, count); |
853 | if (IS_ERR(ptr: buff)) |
854 | return PTR_ERR(ptr: buff); |
855 | |
856 | total_written = qsfp_write(ppd, target, addr: *ppos, bp: buff, len: count); |
857 | if (total_written < 0) { |
858 | ret = total_written; |
859 | goto _free; |
860 | } |
861 | |
862 | *ppos += total_written; |
863 | |
864 | ret = total_written; |
865 | |
866 | _free: |
867 | kfree(objp: buff); |
868 | return ret; |
869 | } |
870 | |
871 | /* Do a QSFP write operation on i2c chain for HFI 0. */ |
872 | static ssize_t qsfp1_debugfs_write(struct file *file, const char __user *buf, |
873 | size_t count, loff_t *ppos) |
874 | { |
875 | return __qsfp_debugfs_write(file, buf, count, ppos, target: 0); |
876 | } |
877 | |
878 | /* Do a QSFP write operation on i2c chain for HFI 1. */ |
879 | static ssize_t qsfp2_debugfs_write(struct file *file, const char __user *buf, |
880 | size_t count, loff_t *ppos) |
881 | { |
882 | return __qsfp_debugfs_write(file, buf, count, ppos, target: 1); |
883 | } |
884 | |
885 | /* Do a QSFP read operation on the i2c chain for the given HFI. */ |
886 | static ssize_t __qsfp_debugfs_read(struct file *file, char __user *buf, |
887 | size_t count, loff_t *ppos, u32 target) |
888 | { |
889 | struct hfi1_pportdata *ppd; |
890 | char *buff; |
891 | int ret; |
892 | int total_read; |
893 | |
894 | if (*ppos + count > QSFP_PAGESIZE * 4) { /* base page + page00-page03 */ |
895 | ret = -EINVAL; |
896 | goto _return; |
897 | } |
898 | |
899 | ppd = private2ppd(file); |
900 | |
901 | buff = kmalloc(size: count, GFP_KERNEL); |
902 | if (!buff) { |
903 | ret = -ENOMEM; |
904 | goto _return; |
905 | } |
906 | |
907 | total_read = qsfp_read(ppd, target, addr: *ppos, bp: buff, len: count); |
908 | if (total_read < 0) { |
909 | ret = total_read; |
910 | goto _free; |
911 | } |
912 | |
913 | *ppos += total_read; |
914 | |
915 | ret = copy_to_user(to: buf, from: buff, n: total_read); |
916 | if (ret > 0) { |
917 | ret = -EFAULT; |
918 | goto _free; |
919 | } |
920 | |
921 | ret = total_read; |
922 | |
923 | _free: |
924 | kfree(objp: buff); |
925 | _return: |
926 | return ret; |
927 | } |
928 | |
929 | /* Do a QSFP read operation on i2c chain for HFI 0. */ |
930 | static ssize_t qsfp1_debugfs_read(struct file *file, char __user *buf, |
931 | size_t count, loff_t *ppos) |
932 | { |
933 | return __qsfp_debugfs_read(file, buf, count, ppos, target: 0); |
934 | } |
935 | |
936 | /* Do a QSFP read operation on i2c chain for HFI 1. */ |
937 | static ssize_t qsfp2_debugfs_read(struct file *file, char __user *buf, |
938 | size_t count, loff_t *ppos) |
939 | { |
940 | return __qsfp_debugfs_read(file, buf, count, ppos, target: 1); |
941 | } |
942 | |
943 | static int __i2c_debugfs_open(struct inode *in, struct file *fp, u32 target) |
944 | { |
945 | struct hfi1_pportdata *ppd; |
946 | |
947 | ppd = private2ppd(fp); |
948 | |
949 | return acquire_chip_resource(dd: ppd->dd, resource: i2c_target(target), mswait: 0); |
950 | } |
951 | |
952 | static int i2c1_debugfs_open(struct inode *in, struct file *fp) |
953 | { |
954 | return __i2c_debugfs_open(in, fp, target: 0); |
955 | } |
956 | |
957 | static int i2c2_debugfs_open(struct inode *in, struct file *fp) |
958 | { |
959 | return __i2c_debugfs_open(in, fp, target: 1); |
960 | } |
961 | |
962 | static int __i2c_debugfs_release(struct inode *in, struct file *fp, u32 target) |
963 | { |
964 | struct hfi1_pportdata *ppd; |
965 | |
966 | ppd = private2ppd(fp); |
967 | |
968 | release_chip_resource(dd: ppd->dd, resource: i2c_target(target)); |
969 | |
970 | return 0; |
971 | } |
972 | |
973 | static int i2c1_debugfs_release(struct inode *in, struct file *fp) |
974 | { |
975 | return __i2c_debugfs_release(in, fp, target: 0); |
976 | } |
977 | |
978 | static int i2c2_debugfs_release(struct inode *in, struct file *fp) |
979 | { |
980 | return __i2c_debugfs_release(in, fp, target: 1); |
981 | } |
982 | |
983 | static int __qsfp_debugfs_open(struct inode *in, struct file *fp, u32 target) |
984 | { |
985 | struct hfi1_pportdata *ppd; |
986 | |
987 | ppd = private2ppd(fp); |
988 | |
989 | return acquire_chip_resource(dd: ppd->dd, resource: i2c_target(target), mswait: 0); |
990 | } |
991 | |
992 | static int qsfp1_debugfs_open(struct inode *in, struct file *fp) |
993 | { |
994 | return __qsfp_debugfs_open(in, fp, target: 0); |
995 | } |
996 | |
997 | static int qsfp2_debugfs_open(struct inode *in, struct file *fp) |
998 | { |
999 | return __qsfp_debugfs_open(in, fp, target: 1); |
1000 | } |
1001 | |
1002 | static int __qsfp_debugfs_release(struct inode *in, struct file *fp, u32 target) |
1003 | { |
1004 | struct hfi1_pportdata *ppd; |
1005 | |
1006 | ppd = private2ppd(fp); |
1007 | |
1008 | release_chip_resource(dd: ppd->dd, resource: i2c_target(target)); |
1009 | |
1010 | return 0; |
1011 | } |
1012 | |
1013 | static int qsfp1_debugfs_release(struct inode *in, struct file *fp) |
1014 | { |
1015 | return __qsfp_debugfs_release(in, fp, target: 0); |
1016 | } |
1017 | |
1018 | static int qsfp2_debugfs_release(struct inode *in, struct file *fp) |
1019 | { |
1020 | return __qsfp_debugfs_release(in, fp, target: 1); |
1021 | } |
1022 | |
1023 | #define EXPROM_WRITE_ENABLE BIT_ULL(14) |
1024 | |
1025 | static bool exprom_wp_disabled; |
1026 | |
1027 | static int exprom_wp_set(struct hfi1_devdata *dd, bool disable) |
1028 | { |
1029 | u64 gpio_val = 0; |
1030 | |
1031 | if (disable) { |
1032 | gpio_val = EXPROM_WRITE_ENABLE; |
1033 | exprom_wp_disabled = true; |
1034 | dd_dev_info(dd, "Disable Expansion ROM Write Protection\n" ); |
1035 | } else { |
1036 | exprom_wp_disabled = false; |
1037 | dd_dev_info(dd, "Enable Expansion ROM Write Protection\n" ); |
1038 | } |
1039 | |
1040 | write_csr(dd, ASIC_GPIO_OUT, value: gpio_val); |
1041 | write_csr(dd, ASIC_GPIO_OE, value: gpio_val); |
1042 | |
1043 | return 0; |
1044 | } |
1045 | |
1046 | static ssize_t exprom_wp_debugfs_read(struct file *file, char __user *buf, |
1047 | size_t count, loff_t *ppos) |
1048 | { |
1049 | return 0; |
1050 | } |
1051 | |
1052 | static ssize_t exprom_wp_debugfs_write(struct file *file, |
1053 | const char __user *buf, size_t count, |
1054 | loff_t *ppos) |
1055 | { |
1056 | struct hfi1_pportdata *ppd = private2ppd(file); |
1057 | char cdata; |
1058 | |
1059 | if (count != 1) |
1060 | return -EINVAL; |
1061 | if (get_user(cdata, buf)) |
1062 | return -EFAULT; |
1063 | if (cdata == '0') |
1064 | exprom_wp_set(dd: ppd->dd, disable: false); |
1065 | else if (cdata == '1') |
1066 | exprom_wp_set(dd: ppd->dd, disable: true); |
1067 | else |
1068 | return -EINVAL; |
1069 | |
1070 | return 1; |
1071 | } |
1072 | |
1073 | static unsigned long exprom_in_use; |
1074 | |
1075 | static int exprom_wp_debugfs_open(struct inode *in, struct file *fp) |
1076 | { |
1077 | if (test_and_set_bit(nr: 0, addr: &exprom_in_use)) |
1078 | return -EBUSY; |
1079 | |
1080 | return 0; |
1081 | } |
1082 | |
1083 | static int exprom_wp_debugfs_release(struct inode *in, struct file *fp) |
1084 | { |
1085 | struct hfi1_pportdata *ppd = private2ppd(fp); |
1086 | |
1087 | if (exprom_wp_disabled) |
1088 | exprom_wp_set(dd: ppd->dd, disable: false); |
1089 | clear_bit(nr: 0, addr: &exprom_in_use); |
1090 | |
1091 | return 0; |
1092 | } |
1093 | |
1094 | #define DEBUGFS_OPS(nm, readroutine, writeroutine) \ |
1095 | { \ |
1096 | .name = nm, \ |
1097 | .ops = { \ |
1098 | .owner = THIS_MODULE, \ |
1099 | .read = readroutine, \ |
1100 | .write = writeroutine, \ |
1101 | .llseek = generic_file_llseek, \ |
1102 | }, \ |
1103 | } |
1104 | |
1105 | #define DEBUGFS_XOPS(nm, readf, writef, openf, releasef) \ |
1106 | { \ |
1107 | .name = nm, \ |
1108 | .ops = { \ |
1109 | .owner = THIS_MODULE, \ |
1110 | .read = readf, \ |
1111 | .write = writef, \ |
1112 | .llseek = generic_file_llseek, \ |
1113 | .open = openf, \ |
1114 | .release = releasef \ |
1115 | }, \ |
1116 | } |
1117 | |
1118 | static const struct counter_info cntr_ops[] = { |
1119 | DEBUGFS_OPS("counter_names" , dev_names_read, NULL), |
1120 | DEBUGFS_OPS("counters" , dev_counters_read, NULL), |
1121 | DEBUGFS_OPS("portcounter_names" , portnames_read, NULL), |
1122 | }; |
1123 | |
1124 | static const struct counter_info port_cntr_ops[] = { |
1125 | DEBUGFS_OPS("port%dcounters" , portcntrs_debugfs_read, NULL), |
1126 | DEBUGFS_XOPS("i2c1" , i2c1_debugfs_read, i2c1_debugfs_write, |
1127 | i2c1_debugfs_open, i2c1_debugfs_release), |
1128 | DEBUGFS_XOPS("i2c2" , i2c2_debugfs_read, i2c2_debugfs_write, |
1129 | i2c2_debugfs_open, i2c2_debugfs_release), |
1130 | DEBUGFS_OPS("qsfp_dump%d" , qsfp_debugfs_dump, NULL), |
1131 | DEBUGFS_XOPS("qsfp1" , qsfp1_debugfs_read, qsfp1_debugfs_write, |
1132 | qsfp1_debugfs_open, qsfp1_debugfs_release), |
1133 | DEBUGFS_XOPS("qsfp2" , qsfp2_debugfs_read, qsfp2_debugfs_write, |
1134 | qsfp2_debugfs_open, qsfp2_debugfs_release), |
1135 | DEBUGFS_XOPS("exprom_wp" , exprom_wp_debugfs_read, |
1136 | exprom_wp_debugfs_write, exprom_wp_debugfs_open, |
1137 | exprom_wp_debugfs_release), |
1138 | DEBUGFS_OPS("asic_flags" , asic_flags_read, asic_flags_write), |
1139 | DEBUGFS_OPS("dc8051_memory" , dc8051_memory_read, NULL), |
1140 | DEBUGFS_OPS("lcb" , debugfs_lcb_read, debugfs_lcb_write), |
1141 | }; |
1142 | |
1143 | static void *_sdma_cpu_list_seq_start(struct seq_file *s, loff_t *pos) |
1144 | { |
1145 | if (*pos >= num_online_cpus()) |
1146 | return NULL; |
1147 | |
1148 | return pos; |
1149 | } |
1150 | |
1151 | static void *_sdma_cpu_list_seq_next(struct seq_file *s, void *v, loff_t *pos) |
1152 | { |
1153 | ++*pos; |
1154 | if (*pos >= num_online_cpus()) |
1155 | return NULL; |
1156 | |
1157 | return pos; |
1158 | } |
1159 | |
1160 | static void _sdma_cpu_list_seq_stop(struct seq_file *s, void *v) |
1161 | { |
1162 | /* nothing allocated */ |
1163 | } |
1164 | |
1165 | static int _sdma_cpu_list_seq_show(struct seq_file *s, void *v) |
1166 | { |
1167 | struct hfi1_ibdev *ibd = (struct hfi1_ibdev *)s->private; |
1168 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
1169 | loff_t *spos = v; |
1170 | loff_t i = *spos; |
1171 | |
1172 | sdma_seqfile_dump_cpu_list(s, dd, cpuid: (unsigned long)i); |
1173 | return 0; |
1174 | } |
1175 | |
1176 | DEBUGFS_SEQ_FILE_OPS(sdma_cpu_list); |
1177 | DEBUGFS_SEQ_FILE_OPEN(sdma_cpu_list) |
1178 | DEBUGFS_FILE_OPS(sdma_cpu_list); |
1179 | |
1180 | void hfi1_dbg_ibdev_init(struct hfi1_ibdev *ibd) |
1181 | { |
1182 | char name[sizeof("port0counters" ) + 1]; |
1183 | char link[10]; |
1184 | struct hfi1_devdata *dd = dd_from_dev(dev: ibd); |
1185 | struct hfi1_pportdata *ppd; |
1186 | struct dentry *root; |
1187 | int unit = dd->unit; |
1188 | int i, j; |
1189 | |
1190 | if (!hfi1_dbg_root) |
1191 | return; |
1192 | snprintf(buf: name, size: sizeof(name), fmt: "%s_%d" , class_name(), unit); |
1193 | snprintf(buf: link, size: sizeof(link), fmt: "%d" , unit); |
1194 | root = debugfs_create_dir(name, parent: hfi1_dbg_root); |
1195 | ibd->hfi1_ibdev_dbg = root; |
1196 | |
1197 | ibd->hfi1_ibdev_link = |
1198 | debugfs_create_symlink(name: link, parent: hfi1_dbg_root, dest: name); |
1199 | |
1200 | debugfs_create_file(name: "opcode_stats" , mode: 0444, parent: root, data: ibd, |
1201 | fops: &_opcode_stats_file_ops); |
1202 | debugfs_create_file(name: "tx_opcode_stats" , mode: 0444, parent: root, data: ibd, |
1203 | fops: &_tx_opcode_stats_file_ops); |
1204 | debugfs_create_file(name: "ctx_stats" , mode: 0444, parent: root, data: ibd, fops: &_ctx_stats_file_ops); |
1205 | debugfs_create_file(name: "qp_stats" , mode: 0444, parent: root, data: ibd, fops: &_qp_stats_file_ops); |
1206 | debugfs_create_file(name: "sdes" , mode: 0444, parent: root, data: ibd, fops: &_sdes_file_ops); |
1207 | debugfs_create_file(name: "rcds" , mode: 0444, parent: root, data: ibd, fops: &_rcds_file_ops); |
1208 | debugfs_create_file(name: "pios" , mode: 0444, parent: root, data: ibd, fops: &_pios_file_ops); |
1209 | debugfs_create_file(name: "sdma_cpu_list" , mode: 0444, parent: root, data: ibd, |
1210 | fops: &_sdma_cpu_list_file_ops); |
1211 | |
1212 | /* dev counter files */ |
1213 | for (i = 0; i < ARRAY_SIZE(cntr_ops); i++) |
1214 | debugfs_create_file(name: cntr_ops[i].name, mode: 0444, parent: root, data: dd, |
1215 | fops: &cntr_ops[i].ops); |
1216 | |
1217 | /* per port files */ |
1218 | for (ppd = dd->pport, j = 0; j < dd->num_pports; j++, ppd++) |
1219 | for (i = 0; i < ARRAY_SIZE(port_cntr_ops); i++) { |
1220 | snprintf(buf: name, |
1221 | size: sizeof(name), |
1222 | fmt: port_cntr_ops[i].name, |
1223 | j + 1); |
1224 | debugfs_create_file(name, |
1225 | mode: !port_cntr_ops[i].ops.write ? |
1226 | S_IRUGO : |
1227 | S_IRUGO | S_IWUSR, |
1228 | parent: root, data: ppd, fops: &port_cntr_ops[i].ops); |
1229 | } |
1230 | |
1231 | hfi1_fault_init_debugfs(ibd); |
1232 | } |
1233 | |
1234 | void hfi1_dbg_ibdev_exit(struct hfi1_ibdev *ibd) |
1235 | { |
1236 | if (!hfi1_dbg_root) |
1237 | goto out; |
1238 | hfi1_fault_exit_debugfs(ibd); |
1239 | debugfs_remove(dentry: ibd->hfi1_ibdev_link); |
1240 | debugfs_remove_recursive(dentry: ibd->hfi1_ibdev_dbg); |
1241 | out: |
1242 | ibd->hfi1_ibdev_dbg = NULL; |
1243 | } |
1244 | |
1245 | /* |
1246 | * driver stats field names, one line per stat, single string. Used by |
1247 | * programs like hfistats to print the stats in a way which works for |
1248 | * different versions of drivers, without changing program source. |
1249 | * if hfi1_ib_stats changes, this needs to change. Names need to be |
1250 | * 12 chars or less (w/o newline), for proper display by hfistats utility. |
1251 | */ |
1252 | static const char * const hfi1_statnames[] = { |
1253 | /* must be element 0*/ |
1254 | "KernIntr" , |
1255 | "ErrorIntr" , |
1256 | "Tx_Errs" , |
1257 | "Rcv_Errs" , |
1258 | "H/W_Errs" , |
1259 | "NoPIOBufs" , |
1260 | "CtxtsOpen" , |
1261 | "RcvLen_Errs" , |
1262 | "EgrBufFull" , |
1263 | "EgrHdrFull" |
1264 | }; |
1265 | |
1266 | static void *_driver_stats_names_seq_start(struct seq_file *s, loff_t *pos) |
1267 | { |
1268 | if (*pos >= ARRAY_SIZE(hfi1_statnames)) |
1269 | return NULL; |
1270 | return pos; |
1271 | } |
1272 | |
1273 | static void *_driver_stats_names_seq_next( |
1274 | struct seq_file *s, |
1275 | void *v, |
1276 | loff_t *pos) |
1277 | { |
1278 | ++*pos; |
1279 | if (*pos >= ARRAY_SIZE(hfi1_statnames)) |
1280 | return NULL; |
1281 | return pos; |
1282 | } |
1283 | |
1284 | static void _driver_stats_names_seq_stop(struct seq_file *s, void *v) |
1285 | { |
1286 | } |
1287 | |
1288 | static int _driver_stats_names_seq_show(struct seq_file *s, void *v) |
1289 | { |
1290 | loff_t *spos = v; |
1291 | |
1292 | seq_printf(m: s, fmt: "%s\n" , hfi1_statnames[*spos]); |
1293 | return 0; |
1294 | } |
1295 | |
1296 | DEBUGFS_SEQ_FILE_OPS(driver_stats_names); |
1297 | DEBUGFS_SEQ_FILE_OPEN(driver_stats_names) |
1298 | DEBUGFS_FILE_OPS(driver_stats_names); |
1299 | |
1300 | static void *_driver_stats_seq_start(struct seq_file *s, loff_t *pos) |
1301 | { |
1302 | if (*pos >= ARRAY_SIZE(hfi1_statnames)) |
1303 | return NULL; |
1304 | return pos; |
1305 | } |
1306 | |
1307 | static void *_driver_stats_seq_next(struct seq_file *s, void *v, loff_t *pos) |
1308 | { |
1309 | ++*pos; |
1310 | if (*pos >= ARRAY_SIZE(hfi1_statnames)) |
1311 | return NULL; |
1312 | return pos; |
1313 | } |
1314 | |
1315 | static void _driver_stats_seq_stop(struct seq_file *s, void *v) |
1316 | { |
1317 | } |
1318 | |
1319 | static void hfi1_sps_show_ints(struct seq_file *s) |
1320 | { |
1321 | unsigned long index, flags; |
1322 | struct hfi1_devdata *dd; |
1323 | u64 sps_ints = 0; |
1324 | |
1325 | xa_lock_irqsave(&hfi1_dev_table, flags); |
1326 | xa_for_each(&hfi1_dev_table, index, dd) { |
1327 | sps_ints += get_all_cpu_total(cntr: dd->int_counter); |
1328 | } |
1329 | xa_unlock_irqrestore(&hfi1_dev_table, flags); |
1330 | seq_write(seq: s, data: &sps_ints, len: sizeof(u64)); |
1331 | } |
1332 | |
1333 | static int _driver_stats_seq_show(struct seq_file *s, void *v) |
1334 | { |
1335 | loff_t *spos = v; |
1336 | u64 *stats = (u64 *)&hfi1_stats; |
1337 | |
1338 | /* special case for interrupts */ |
1339 | if (*spos == 0) |
1340 | hfi1_sps_show_ints(s); |
1341 | else |
1342 | seq_write(seq: s, data: stats + *spos, len: sizeof(u64)); |
1343 | return 0; |
1344 | } |
1345 | |
1346 | DEBUGFS_SEQ_FILE_OPS(driver_stats); |
1347 | DEBUGFS_SEQ_FILE_OPEN(driver_stats) |
1348 | DEBUGFS_FILE_OPS(driver_stats); |
1349 | |
1350 | void hfi1_dbg_init(void) |
1351 | { |
1352 | hfi1_dbg_root = debugfs_create_dir(DRIVER_NAME, NULL); |
1353 | debugfs_create_file(name: "driver_stats_names" , mode: 0444, parent: hfi1_dbg_root, NULL, |
1354 | fops: &_driver_stats_names_file_ops); |
1355 | debugfs_create_file(name: "driver_stats" , mode: 0444, parent: hfi1_dbg_root, NULL, |
1356 | fops: &_driver_stats_file_ops); |
1357 | } |
1358 | |
1359 | void hfi1_dbg_exit(void) |
1360 | { |
1361 | debugfs_remove_recursive(dentry: hfi1_dbg_root); |
1362 | hfi1_dbg_root = NULL; |
1363 | } |
1364 | |