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