Loading...
1/* Intel(R) Ethernet Switch Host Interface Driver
2 * Copyright(c) 2013 - 2016 Intel Corporation.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * The full GNU General Public License is included in this distribution in
14 * the file called "COPYING".
15 *
16 * Contact Information:
17 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
18 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
19 */
20
21#include "fm10k.h"
22
23#include <linux/debugfs.h>
24#include <linux/seq_file.h>
25
26static struct dentry *dbg_root;
27
28/* Descriptor Seq Functions */
29
30static void *fm10k_dbg_desc_seq_start(struct seq_file *s, loff_t *pos)
31{
32 struct fm10k_ring *ring = s->private;
33
34 return (*pos < ring->count) ? pos : NULL;
35}
36
37static void *fm10k_dbg_desc_seq_next(struct seq_file *s,
38 void __always_unused *v,
39 loff_t *pos)
40{
41 struct fm10k_ring *ring = s->private;
42
43 return (++(*pos) < ring->count) ? pos : NULL;
44}
45
46static void fm10k_dbg_desc_seq_stop(struct seq_file __always_unused *s,
47 void __always_unused *v)
48{
49 /* Do nothing. */
50}
51
52static void fm10k_dbg_desc_break(struct seq_file *s, int i)
53{
54 while (i--)
55 seq_puts(s, "-");
56
57 seq_puts(s, "\n");
58}
59
60static int fm10k_dbg_tx_desc_seq_show(struct seq_file *s, void *v)
61{
62 struct fm10k_ring *ring = s->private;
63 int i = *(loff_t *)v;
64 static const char tx_desc_hdr[] =
65 "DES BUFFER_ADDRESS LENGTH VLAN MSS HDRLEN FLAGS\n";
66
67 /* Generate header */
68 if (!i) {
69 seq_printf(s, tx_desc_hdr);
70 fm10k_dbg_desc_break(s, sizeof(tx_desc_hdr) - 1);
71 }
72
73 /* Validate descriptor allocation */
74 if (!ring->desc) {
75 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
76 } else {
77 struct fm10k_tx_desc *txd = FM10K_TX_DESC(ring, i);
78
79 seq_printf(s, "%03X %#018llx %#06x %#06x %#06x %#06x %#04x\n",
80 i, txd->buffer_addr, txd->buflen, txd->vlan,
81 txd->mss, txd->hdrlen, txd->flags);
82 }
83
84 return 0;
85}
86
87static int fm10k_dbg_rx_desc_seq_show(struct seq_file *s, void *v)
88{
89 struct fm10k_ring *ring = s->private;
90 int i = *(loff_t *)v;
91 static const char rx_desc_hdr[] =
92 "DES DATA RSS STATERR LENGTH VLAN DGLORT SGLORT TIMESTAMP\n";
93
94 /* Generate header */
95 if (!i) {
96 seq_printf(s, rx_desc_hdr);
97 fm10k_dbg_desc_break(s, sizeof(rx_desc_hdr) - 1);
98 }
99
100 /* Validate descriptor allocation */
101 if (!ring->desc) {
102 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
103 } else {
104 union fm10k_rx_desc *rxd = FM10K_RX_DESC(ring, i);
105
106 seq_printf(s,
107 "%03X %#010x %#010x %#010x %#06x %#06x %#06x %#06x %#018llx\n",
108 i, rxd->d.data, rxd->d.rss, rxd->d.staterr,
109 rxd->w.length, rxd->w.vlan, rxd->w.dglort,
110 rxd->w.sglort, rxd->q.timestamp);
111 }
112
113 return 0;
114}
115
116static const struct seq_operations fm10k_dbg_tx_desc_seq_ops = {
117 .start = fm10k_dbg_desc_seq_start,
118 .next = fm10k_dbg_desc_seq_next,
119 .stop = fm10k_dbg_desc_seq_stop,
120 .show = fm10k_dbg_tx_desc_seq_show,
121};
122
123static const struct seq_operations fm10k_dbg_rx_desc_seq_ops = {
124 .start = fm10k_dbg_desc_seq_start,
125 .next = fm10k_dbg_desc_seq_next,
126 .stop = fm10k_dbg_desc_seq_stop,
127 .show = fm10k_dbg_rx_desc_seq_show,
128};
129
130static int fm10k_dbg_desc_open(struct inode *inode, struct file *filep)
131{
132 struct fm10k_ring *ring = inode->i_private;
133 struct fm10k_q_vector *q_vector = ring->q_vector;
134 const struct seq_operations *desc_seq_ops;
135 int err;
136
137 if (ring < q_vector->rx.ring)
138 desc_seq_ops = &fm10k_dbg_tx_desc_seq_ops;
139 else
140 desc_seq_ops = &fm10k_dbg_rx_desc_seq_ops;
141
142 err = seq_open(filep, desc_seq_ops);
143 if (err)
144 return err;
145
146 ((struct seq_file *)filep->private_data)->private = ring;
147
148 return 0;
149}
150
151static const struct file_operations fm10k_dbg_desc_fops = {
152 .owner = THIS_MODULE,
153 .open = fm10k_dbg_desc_open,
154 .read = seq_read,
155 .llseek = seq_lseek,
156 .release = seq_release,
157};
158
159/**
160 * fm10k_dbg_q_vector_init - setup debugfs for the q_vectors
161 * @q_vector: q_vector to allocate directories for
162 *
163 * A folder is created for each q_vector found. In each q_vector
164 * folder, a debugfs file is created for each tx and rx ring
165 * allocated to the q_vector.
166 **/
167void fm10k_dbg_q_vector_init(struct fm10k_q_vector *q_vector)
168{
169 struct fm10k_intfc *interface = q_vector->interface;
170 char name[16];
171 int i;
172
173 if (!interface->dbg_intfc)
174 return;
175
176 /* Generate a folder for each q_vector */
177 snprintf(name, sizeof(name), "q_vector.%03d", q_vector->v_idx);
178
179 q_vector->dbg_q_vector = debugfs_create_dir(name, interface->dbg_intfc);
180 if (!q_vector->dbg_q_vector)
181 return;
182
183 /* Generate a file for each rx ring in the q_vector */
184 for (i = 0; i < q_vector->tx.count; i++) {
185 struct fm10k_ring *ring = &q_vector->tx.ring[i];
186
187 snprintf(name, sizeof(name), "tx_ring.%03d", ring->queue_index);
188
189 debugfs_create_file(name, 0600,
190 q_vector->dbg_q_vector, ring,
191 &fm10k_dbg_desc_fops);
192 }
193
194 /* Generate a file for each rx ring in the q_vector */
195 for (i = 0; i < q_vector->rx.count; i++) {
196 struct fm10k_ring *ring = &q_vector->rx.ring[i];
197
198 snprintf(name, sizeof(name), "rx_ring.%03d", ring->queue_index);
199
200 debugfs_create_file(name, 0600,
201 q_vector->dbg_q_vector, ring,
202 &fm10k_dbg_desc_fops);
203 }
204}
205
206/**
207 * fm10k_dbg_free_q_vector_dir - setup debugfs for the q_vectors
208 * @q_vector: q_vector to allocate directories for
209 **/
210void fm10k_dbg_q_vector_exit(struct fm10k_q_vector *q_vector)
211{
212 struct fm10k_intfc *interface = q_vector->interface;
213
214 if (interface->dbg_intfc)
215 debugfs_remove_recursive(q_vector->dbg_q_vector);
216 q_vector->dbg_q_vector = NULL;
217}
218
219/**
220 * fm10k_dbg_intfc_init - setup the debugfs directory for the intferface
221 * @interface: the interface that is starting up
222 **/
223
224void fm10k_dbg_intfc_init(struct fm10k_intfc *interface)
225{
226 const char *name = pci_name(interface->pdev);
227
228 if (dbg_root)
229 interface->dbg_intfc = debugfs_create_dir(name, dbg_root);
230}
231
232/**
233 * fm10k_dbg_intfc_exit - clean out the interface's debugfs entries
234 * @interface: the interface that is stopping
235 **/
236void fm10k_dbg_intfc_exit(struct fm10k_intfc *interface)
237{
238 if (dbg_root)
239 debugfs_remove_recursive(interface->dbg_intfc);
240 interface->dbg_intfc = NULL;
241}
242
243/**
244 * fm10k_dbg_init - start up debugfs for the driver
245 **/
246void fm10k_dbg_init(void)
247{
248 dbg_root = debugfs_create_dir(fm10k_driver_name, NULL);
249}
250
251/**
252 * fm10k_dbg_exit - clean out the driver's debugfs entries
253 **/
254void fm10k_dbg_exit(void)
255{
256 debugfs_remove_recursive(dbg_root);
257 dbg_root = NULL;
258}
1// SPDX-License-Identifier: GPL-2.0
2/* Intel(R) Ethernet Switch Host Interface Driver
3 * Copyright(c) 2013 - 2016 Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * The full GNU General Public License is included in this distribution in
15 * the file called "COPYING".
16 *
17 * Contact Information:
18 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
19 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
20 */
21
22#include "fm10k.h"
23
24#include <linux/debugfs.h>
25#include <linux/seq_file.h>
26
27static struct dentry *dbg_root;
28
29/* Descriptor Seq Functions */
30
31static void *fm10k_dbg_desc_seq_start(struct seq_file *s, loff_t *pos)
32{
33 struct fm10k_ring *ring = s->private;
34
35 return (*pos < ring->count) ? pos : NULL;
36}
37
38static void *fm10k_dbg_desc_seq_next(struct seq_file *s,
39 void __always_unused *v,
40 loff_t *pos)
41{
42 struct fm10k_ring *ring = s->private;
43
44 return (++(*pos) < ring->count) ? pos : NULL;
45}
46
47static void fm10k_dbg_desc_seq_stop(struct seq_file __always_unused *s,
48 void __always_unused *v)
49{
50 /* Do nothing. */
51}
52
53static void fm10k_dbg_desc_break(struct seq_file *s, int i)
54{
55 while (i--)
56 seq_putc(s, '-');
57
58 seq_putc(s, '\n');
59}
60
61static int fm10k_dbg_tx_desc_seq_show(struct seq_file *s, void *v)
62{
63 struct fm10k_ring *ring = s->private;
64 int i = *(loff_t *)v;
65 static const char tx_desc_hdr[] =
66 "DES BUFFER_ADDRESS LENGTH VLAN MSS HDRLEN FLAGS\n";
67
68 /* Generate header */
69 if (!i) {
70 seq_printf(s, tx_desc_hdr);
71 fm10k_dbg_desc_break(s, sizeof(tx_desc_hdr) - 1);
72 }
73
74 /* Validate descriptor allocation */
75 if (!ring->desc) {
76 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
77 } else {
78 struct fm10k_tx_desc *txd = FM10K_TX_DESC(ring, i);
79
80 seq_printf(s, "%03X %#018llx %#06x %#06x %#06x %#06x %#04x\n",
81 i, txd->buffer_addr, txd->buflen, txd->vlan,
82 txd->mss, txd->hdrlen, txd->flags);
83 }
84
85 return 0;
86}
87
88static int fm10k_dbg_rx_desc_seq_show(struct seq_file *s, void *v)
89{
90 struct fm10k_ring *ring = s->private;
91 int i = *(loff_t *)v;
92 static const char rx_desc_hdr[] =
93 "DES DATA RSS STATERR LENGTH VLAN DGLORT SGLORT TIMESTAMP\n";
94
95 /* Generate header */
96 if (!i) {
97 seq_printf(s, rx_desc_hdr);
98 fm10k_dbg_desc_break(s, sizeof(rx_desc_hdr) - 1);
99 }
100
101 /* Validate descriptor allocation */
102 if (!ring->desc) {
103 seq_printf(s, "%03X Descriptor ring not allocated.\n", i);
104 } else {
105 union fm10k_rx_desc *rxd = FM10K_RX_DESC(ring, i);
106
107 seq_printf(s,
108 "%03X %#010x %#010x %#010x %#06x %#06x %#06x %#06x %#018llx\n",
109 i, rxd->d.data, rxd->d.rss, rxd->d.staterr,
110 rxd->w.length, rxd->w.vlan, rxd->w.dglort,
111 rxd->w.sglort, rxd->q.timestamp);
112 }
113
114 return 0;
115}
116
117static const struct seq_operations fm10k_dbg_tx_desc_seq_ops = {
118 .start = fm10k_dbg_desc_seq_start,
119 .next = fm10k_dbg_desc_seq_next,
120 .stop = fm10k_dbg_desc_seq_stop,
121 .show = fm10k_dbg_tx_desc_seq_show,
122};
123
124static const struct seq_operations fm10k_dbg_rx_desc_seq_ops = {
125 .start = fm10k_dbg_desc_seq_start,
126 .next = fm10k_dbg_desc_seq_next,
127 .stop = fm10k_dbg_desc_seq_stop,
128 .show = fm10k_dbg_rx_desc_seq_show,
129};
130
131static int fm10k_dbg_desc_open(struct inode *inode, struct file *filep)
132{
133 struct fm10k_ring *ring = inode->i_private;
134 struct fm10k_q_vector *q_vector = ring->q_vector;
135 const struct seq_operations *desc_seq_ops;
136 int err;
137
138 if (ring < q_vector->rx.ring)
139 desc_seq_ops = &fm10k_dbg_tx_desc_seq_ops;
140 else
141 desc_seq_ops = &fm10k_dbg_rx_desc_seq_ops;
142
143 err = seq_open(filep, desc_seq_ops);
144 if (err)
145 return err;
146
147 ((struct seq_file *)filep->private_data)->private = ring;
148
149 return 0;
150}
151
152static const struct file_operations fm10k_dbg_desc_fops = {
153 .owner = THIS_MODULE,
154 .open = fm10k_dbg_desc_open,
155 .read = seq_read,
156 .llseek = seq_lseek,
157 .release = seq_release,
158};
159
160/**
161 * fm10k_dbg_q_vector_init - setup debugfs for the q_vectors
162 * @q_vector: q_vector to allocate directories for
163 *
164 * A folder is created for each q_vector found. In each q_vector
165 * folder, a debugfs file is created for each tx and rx ring
166 * allocated to the q_vector.
167 **/
168void fm10k_dbg_q_vector_init(struct fm10k_q_vector *q_vector)
169{
170 struct fm10k_intfc *interface = q_vector->interface;
171 char name[16];
172 int i;
173
174 if (!interface->dbg_intfc)
175 return;
176
177 /* Generate a folder for each q_vector */
178 snprintf(name, sizeof(name), "q_vector.%03d", q_vector->v_idx);
179
180 q_vector->dbg_q_vector = debugfs_create_dir(name, interface->dbg_intfc);
181 if (!q_vector->dbg_q_vector)
182 return;
183
184 /* Generate a file for each rx ring in the q_vector */
185 for (i = 0; i < q_vector->tx.count; i++) {
186 struct fm10k_ring *ring = &q_vector->tx.ring[i];
187
188 snprintf(name, sizeof(name), "tx_ring.%03d", ring->queue_index);
189
190 debugfs_create_file(name, 0600,
191 q_vector->dbg_q_vector, ring,
192 &fm10k_dbg_desc_fops);
193 }
194
195 /* Generate a file for each rx ring in the q_vector */
196 for (i = 0; i < q_vector->rx.count; i++) {
197 struct fm10k_ring *ring = &q_vector->rx.ring[i];
198
199 snprintf(name, sizeof(name), "rx_ring.%03d", ring->queue_index);
200
201 debugfs_create_file(name, 0600,
202 q_vector->dbg_q_vector, ring,
203 &fm10k_dbg_desc_fops);
204 }
205}
206
207/**
208 * fm10k_dbg_free_q_vector_dir - setup debugfs for the q_vectors
209 * @q_vector: q_vector to allocate directories for
210 **/
211void fm10k_dbg_q_vector_exit(struct fm10k_q_vector *q_vector)
212{
213 struct fm10k_intfc *interface = q_vector->interface;
214
215 if (interface->dbg_intfc)
216 debugfs_remove_recursive(q_vector->dbg_q_vector);
217 q_vector->dbg_q_vector = NULL;
218}
219
220/**
221 * fm10k_dbg_intfc_init - setup the debugfs directory for the intferface
222 * @interface: the interface that is starting up
223 **/
224
225void fm10k_dbg_intfc_init(struct fm10k_intfc *interface)
226{
227 const char *name = pci_name(interface->pdev);
228
229 if (dbg_root)
230 interface->dbg_intfc = debugfs_create_dir(name, dbg_root);
231}
232
233/**
234 * fm10k_dbg_intfc_exit - clean out the interface's debugfs entries
235 * @interface: the interface that is stopping
236 **/
237void fm10k_dbg_intfc_exit(struct fm10k_intfc *interface)
238{
239 if (dbg_root)
240 debugfs_remove_recursive(interface->dbg_intfc);
241 interface->dbg_intfc = NULL;
242}
243
244/**
245 * fm10k_dbg_init - start up debugfs for the driver
246 **/
247void fm10k_dbg_init(void)
248{
249 dbg_root = debugfs_create_dir(fm10k_driver_name, NULL);
250}
251
252/**
253 * fm10k_dbg_exit - clean out the driver's debugfs entries
254 **/
255void fm10k_dbg_exit(void)
256{
257 debugfs_remove_recursive(dbg_root);
258 dbg_root = NULL;
259}