Commit | Line | Data |
---|---|---|
86641094 JK |
1 | /* Intel(R) Ethernet Switch Host Interface Driver |
2 | * Copyright(c) 2013 - 2016 Intel Corporation. | |
7461fd91 AD |
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 | ||
7461fd91 AD |
21 | #include "fm10k.h" |
22 | ||
23 | #include <linux/debugfs.h> | |
24 | #include <linux/seq_file.h> | |
25 | ||
26 | static struct dentry *dbg_root; | |
27 | ||
28 | /* Descriptor Seq Functions */ | |
29 | ||
30 | static 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 | ||
de445199 | 37 | static void *fm10k_dbg_desc_seq_next(struct seq_file *s, |
6fbc6b35 JK |
38 | void __always_unused *v, |
39 | loff_t *pos) | |
7461fd91 AD |
40 | { |
41 | struct fm10k_ring *ring = s->private; | |
42 | ||
43 | return (++(*pos) < ring->count) ? pos : NULL; | |
44 | } | |
45 | ||
de445199 | 46 | static void fm10k_dbg_desc_seq_stop(struct seq_file __always_unused *s, |
6fbc6b35 | 47 | void __always_unused *v) |
7461fd91 AD |
48 | { |
49 | /* Do nothing. */ | |
50 | } | |
51 | ||
52 | static 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 | ||
60 | static 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 | ||
87 | static 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 | ||
116 | static 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 | ||
123 | static 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 | ||
130 | static 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 | ||
151 | static 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 | **/ | |
167 | void 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 */ | |
f6f19f8b | 177 | snprintf(name, sizeof(name), "q_vector.%03d", q_vector->v_idx); |
7461fd91 AD |
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 | ||
f6f19f8b | 187 | snprintf(name, sizeof(name), "tx_ring.%03d", ring->queue_index); |
7461fd91 AD |
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 | ||
f6f19f8b | 198 | snprintf(name, sizeof(name), "rx_ring.%03d", ring->queue_index); |
7461fd91 AD |
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 | **/ | |
210 | void 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 | ||
224 | void 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 | **/ | |
236 | void 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 | **/ | |
246 | void 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 | **/ | |
254 | void fm10k_dbg_exit(void) | |
255 | { | |
256 | debugfs_remove_recursive(dbg_root); | |
257 | dbg_root = NULL; | |
258 | } |