GNU Linux-libre 4.9.330-gnu1
[releases.git] / drivers / net / ethernet / intel / fm10k / fm10k_debugfs.c
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
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
37 static 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
46 static void fm10k_dbg_desc_seq_stop(struct seq_file __always_unused *s,
47                                     void __always_unused *v)
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 */
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  **/
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 }