replace alignment attributes
[dpdk.git] / drivers / net / octeontx2 / otx2_stats.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(C) 2019 Marvell International Ltd.
3  */
4
5 #include <inttypes.h>
6
7 #include "otx2_ethdev.h"
8
9 struct otx2_nix_xstats_name {
10         char name[RTE_ETH_XSTATS_NAME_SIZE];
11         uint32_t offset;
12 };
13
14 static const struct otx2_nix_xstats_name nix_tx_xstats[] = {
15         {"tx_ucast", NIX_STAT_LF_TX_TX_UCAST},
16         {"tx_bcast", NIX_STAT_LF_TX_TX_BCAST},
17         {"tx_mcast", NIX_STAT_LF_TX_TX_MCAST},
18         {"tx_drop", NIX_STAT_LF_TX_TX_DROP},
19         {"tx_octs", NIX_STAT_LF_TX_TX_OCTS},
20 };
21
22 static const struct otx2_nix_xstats_name nix_rx_xstats[] = {
23         {"rx_octs", NIX_STAT_LF_RX_RX_OCTS},
24         {"rx_ucast", NIX_STAT_LF_RX_RX_UCAST},
25         {"rx_bcast", NIX_STAT_LF_RX_RX_BCAST},
26         {"rx_mcast", NIX_STAT_LF_RX_RX_MCAST},
27         {"rx_drop", NIX_STAT_LF_RX_RX_DROP},
28         {"rx_drop_octs", NIX_STAT_LF_RX_RX_DROP_OCTS},
29         {"rx_fcs", NIX_STAT_LF_RX_RX_FCS},
30         {"rx_err", NIX_STAT_LF_RX_RX_ERR},
31         {"rx_drp_bcast", NIX_STAT_LF_RX_RX_DRP_BCAST},
32         {"rx_drp_mcast", NIX_STAT_LF_RX_RX_DRP_MCAST},
33         {"rx_drp_l3bcast", NIX_STAT_LF_RX_RX_DRP_L3BCAST},
34         {"rx_drp_l3mcast", NIX_STAT_LF_RX_RX_DRP_L3MCAST},
35 };
36
37 static const struct otx2_nix_xstats_name nix_q_xstats[] = {
38         {"rq_op_re_pkts", NIX_LF_RQ_OP_RE_PKTS},
39 };
40
41 #define OTX2_NIX_NUM_RX_XSTATS RTE_DIM(nix_rx_xstats)
42 #define OTX2_NIX_NUM_TX_XSTATS RTE_DIM(nix_tx_xstats)
43 #define OTX2_NIX_NUM_QUEUE_XSTATS RTE_DIM(nix_q_xstats)
44
45 #define OTX2_NIX_NUM_XSTATS_REG (OTX2_NIX_NUM_RX_XSTATS + \
46                 OTX2_NIX_NUM_TX_XSTATS + OTX2_NIX_NUM_QUEUE_XSTATS)
47
48 int
49 otx2_nix_dev_stats_get(struct rte_eth_dev *eth_dev,
50                        struct rte_eth_stats *stats)
51 {
52         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
53         uint64_t reg, val;
54         uint32_t qidx, i;
55         int64_t *addr;
56
57         stats->opackets = otx2_read64(dev->base +
58                         NIX_LF_TX_STATX(NIX_STAT_LF_TX_TX_UCAST));
59         stats->opackets += otx2_read64(dev->base +
60                         NIX_LF_TX_STATX(NIX_STAT_LF_TX_TX_MCAST));
61         stats->opackets += otx2_read64(dev->base +
62                         NIX_LF_TX_STATX(NIX_STAT_LF_TX_TX_BCAST));
63         stats->oerrors = otx2_read64(dev->base +
64                         NIX_LF_TX_STATX(NIX_STAT_LF_TX_TX_DROP));
65         stats->obytes = otx2_read64(dev->base +
66                         NIX_LF_TX_STATX(NIX_STAT_LF_TX_TX_OCTS));
67
68         stats->ipackets = otx2_read64(dev->base +
69                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_UCAST));
70         stats->ipackets += otx2_read64(dev->base +
71                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_MCAST));
72         stats->ipackets += otx2_read64(dev->base +
73                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_BCAST));
74         stats->imissed = otx2_read64(dev->base +
75                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_DROP));
76         stats->ibytes = otx2_read64(dev->base +
77                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_OCTS));
78         stats->ierrors = otx2_read64(dev->base +
79                         NIX_LF_RX_STATX(NIX_STAT_LF_RX_RX_ERR));
80
81         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) {
82                 if (dev->txmap[i] & (1U << 31)) {
83                         qidx = dev->txmap[i] & 0xFFFF;
84                         reg = (((uint64_t)qidx) << 32);
85
86                         addr = (int64_t *)(dev->base + NIX_LF_SQ_OP_PKTS);
87                         val = otx2_atomic64_add_nosync(reg, addr);
88                         if (val & OP_ERR)
89                                 val = 0;
90                         stats->q_opackets[i] = val;
91
92                         addr = (int64_t *)(dev->base + NIX_LF_SQ_OP_OCTS);
93                         val = otx2_atomic64_add_nosync(reg, addr);
94                         if (val & OP_ERR)
95                                 val = 0;
96                         stats->q_obytes[i] = val;
97
98                         addr = (int64_t *)(dev->base + NIX_LF_SQ_OP_DROP_PKTS);
99                         val = otx2_atomic64_add_nosync(reg, addr);
100                         if (val & OP_ERR)
101                                 val = 0;
102                         stats->q_errors[i] = val;
103                 }
104         }
105
106         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS; i++) {
107                 if (dev->rxmap[i] & (1U << 31)) {
108                         qidx = dev->rxmap[i] & 0xFFFF;
109                         reg = (((uint64_t)qidx) << 32);
110
111                         addr = (int64_t *)(dev->base + NIX_LF_RQ_OP_PKTS);
112                         val = otx2_atomic64_add_nosync(reg, addr);
113                         if (val & OP_ERR)
114                                 val = 0;
115                         stats->q_ipackets[i] = val;
116
117                         addr = (int64_t *)(dev->base + NIX_LF_RQ_OP_OCTS);
118                         val = otx2_atomic64_add_nosync(reg, addr);
119                         if (val & OP_ERR)
120                                 val = 0;
121                         stats->q_ibytes[i] = val;
122
123                         addr = (int64_t *)(dev->base + NIX_LF_RQ_OP_DROP_PKTS);
124                         val = otx2_atomic64_add_nosync(reg, addr);
125                         if (val & OP_ERR)
126                                 val = 0;
127                         stats->q_errors[i] += val;
128                 }
129         }
130
131         return 0;
132 }
133
134 int
135 otx2_nix_dev_stats_reset(struct rte_eth_dev *eth_dev)
136 {
137         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
138         struct otx2_mbox *mbox = dev->mbox;
139
140         if (otx2_mbox_alloc_msg_nix_stats_rst(mbox) == NULL)
141                 return -ENOMEM;
142
143         return otx2_mbox_process(mbox);
144 }
145
146 int
147 otx2_nix_queue_stats_mapping(struct rte_eth_dev *eth_dev, uint16_t queue_id,
148                              uint8_t stat_idx, uint8_t is_rx)
149 {
150         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
151
152         if (is_rx)
153                 dev->rxmap[stat_idx] = ((1U << 31) | queue_id);
154         else
155                 dev->txmap[stat_idx] = ((1U << 31) | queue_id);
156
157         return 0;
158 }
159
160 int
161 otx2_nix_xstats_get(struct rte_eth_dev *eth_dev,
162                     struct rte_eth_xstat *xstats,
163                     unsigned int n)
164 {
165         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
166         unsigned int i, count = 0;
167         uint64_t reg, val;
168
169         if (n < OTX2_NIX_NUM_XSTATS_REG)
170                 return OTX2_NIX_NUM_XSTATS_REG;
171
172         if (xstats == NULL)
173                 return 0;
174
175         for (i = 0; i < OTX2_NIX_NUM_TX_XSTATS; i++) {
176                 xstats[count].value = otx2_read64(dev->base +
177                 NIX_LF_TX_STATX(nix_tx_xstats[i].offset));
178                 xstats[count].id = count;
179                 count++;
180         }
181
182         for (i = 0; i < OTX2_NIX_NUM_RX_XSTATS; i++) {
183                 xstats[count].value = otx2_read64(dev->base +
184                 NIX_LF_RX_STATX(nix_rx_xstats[i].offset));
185                 xstats[count].id = count;
186                 count++;
187         }
188
189         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
190                 reg = (((uint64_t)i) << 32);
191                 val = otx2_atomic64_add_nosync(reg, (int64_t *)(dev->base +
192                                                nix_q_xstats[0].offset));
193                 if (val & OP_ERR)
194                         val = 0;
195                 xstats[count].value += val;
196         }
197         xstats[count].id = count;
198         count++;
199
200         return count;
201 }
202
203 int
204 otx2_nix_xstats_get_names(struct rte_eth_dev *eth_dev,
205                           struct rte_eth_xstat_name *xstats_names,
206                           unsigned int limit)
207 {
208         unsigned int i, count = 0;
209
210         RTE_SET_USED(eth_dev);
211
212         if (limit < OTX2_NIX_NUM_XSTATS_REG && xstats_names != NULL)
213                 return -ENOMEM;
214
215         if (xstats_names) {
216                 for (i = 0; i < OTX2_NIX_NUM_TX_XSTATS; i++) {
217                         snprintf(xstats_names[count].name,
218                                  sizeof(xstats_names[count].name),
219                                  "%s", nix_tx_xstats[i].name);
220                         count++;
221                 }
222
223                 for (i = 0; i < OTX2_NIX_NUM_RX_XSTATS; i++) {
224                         snprintf(xstats_names[count].name,
225                                  sizeof(xstats_names[count].name),
226                                  "%s", nix_rx_xstats[i].name);
227                         count++;
228                 }
229
230                 for (i = 0; i < OTX2_NIX_NUM_QUEUE_XSTATS; i++) {
231                         snprintf(xstats_names[count].name,
232                                  sizeof(xstats_names[count].name),
233                                  "%s", nix_q_xstats[i].name);
234                         count++;
235                 }
236         }
237
238         return OTX2_NIX_NUM_XSTATS_REG;
239 }
240
241 int
242 otx2_nix_xstats_get_names_by_id(struct rte_eth_dev *eth_dev,
243                                 struct rte_eth_xstat_name *xstats_names,
244                                 const uint64_t *ids, unsigned int limit)
245 {
246         struct rte_eth_xstat_name xstats_names_copy[OTX2_NIX_NUM_XSTATS_REG];
247         uint16_t i;
248
249         if (limit < OTX2_NIX_NUM_XSTATS_REG && ids == NULL)
250                 return OTX2_NIX_NUM_XSTATS_REG;
251
252         if (limit > OTX2_NIX_NUM_XSTATS_REG)
253                 return -EINVAL;
254
255         if (xstats_names == NULL)
256                 return -ENOMEM;
257
258         otx2_nix_xstats_get_names(eth_dev, xstats_names_copy, limit);
259
260         for (i = 0; i < OTX2_NIX_NUM_XSTATS_REG; i++) {
261                 if (ids[i] >= OTX2_NIX_NUM_XSTATS_REG) {
262                         otx2_err("Invalid id value");
263                         return -EINVAL;
264                 }
265                 strncpy(xstats_names[i].name, xstats_names_copy[ids[i]].name,
266                         sizeof(xstats_names[i].name));
267         }
268
269         return limit;
270 }
271
272 int
273 otx2_nix_xstats_get_by_id(struct rte_eth_dev *eth_dev, const uint64_t *ids,
274                           uint64_t *values, unsigned int n)
275 {
276         struct rte_eth_xstat xstats[OTX2_NIX_NUM_XSTATS_REG];
277         uint16_t i;
278
279         if (n < OTX2_NIX_NUM_XSTATS_REG && ids == NULL)
280                 return OTX2_NIX_NUM_XSTATS_REG;
281
282         if (n > OTX2_NIX_NUM_XSTATS_REG)
283                 return -EINVAL;
284
285         if (values == NULL)
286                 return -ENOMEM;
287
288         otx2_nix_xstats_get(eth_dev, xstats, n);
289
290         for (i = 0; i < OTX2_NIX_NUM_XSTATS_REG; i++) {
291                 if (ids[i] >= OTX2_NIX_NUM_XSTATS_REG) {
292                         otx2_err("Invalid id value");
293                         return -EINVAL;
294                 }
295                 values[i] = xstats[ids[i]].value;
296         }
297
298         return n;
299 }
300
301 static int
302 nix_queue_stats_reset(struct rte_eth_dev *eth_dev)
303 {
304         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
305         struct otx2_mbox *mbox = dev->mbox;
306         struct nix_aq_enq_rsp *rsp;
307         struct nix_aq_enq_req *aq;
308         uint32_t i;
309         int rc;
310
311         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
312                 aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
313                 aq->qidx = i;
314                 aq->ctype = NIX_AQ_CTYPE_RQ;
315                 aq->op = NIX_AQ_INSTOP_READ;
316                 rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
317                 if (rc) {
318                         otx2_err("Failed to read rq context");
319                         return rc;
320                 }
321                 aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
322                 aq->qidx = i;
323                 aq->ctype = NIX_AQ_CTYPE_RQ;
324                 aq->op = NIX_AQ_INSTOP_WRITE;
325                 otx2_mbox_memcpy(&aq->rq, &rsp->rq, sizeof(rsp->rq));
326                 otx2_mbox_memset(&aq->rq_mask, 0, sizeof(aq->rq_mask));
327                 aq->rq.octs = 0;
328                 aq->rq.pkts = 0;
329                 aq->rq.drop_octs = 0;
330                 aq->rq.drop_pkts = 0;
331                 aq->rq.re_pkts = 0;
332
333                 aq->rq_mask.octs = ~(aq->rq_mask.octs);
334                 aq->rq_mask.pkts = ~(aq->rq_mask.pkts);
335                 aq->rq_mask.drop_octs = ~(aq->rq_mask.drop_octs);
336                 aq->rq_mask.drop_pkts = ~(aq->rq_mask.drop_pkts);
337                 aq->rq_mask.re_pkts = ~(aq->rq_mask.re_pkts);
338                 rc = otx2_mbox_process(mbox);
339                 if (rc) {
340                         otx2_err("Failed to write rq context");
341                         return rc;
342                 }
343         }
344
345         for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
346                 aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
347                 aq->qidx = i;
348                 aq->ctype = NIX_AQ_CTYPE_SQ;
349                 aq->op = NIX_AQ_INSTOP_READ;
350                 rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
351                 if (rc) {
352                         otx2_err("Failed to read sq context");
353                         return rc;
354                 }
355                 aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
356                 aq->qidx = i;
357                 aq->ctype = NIX_AQ_CTYPE_SQ;
358                 aq->op = NIX_AQ_INSTOP_WRITE;
359                 otx2_mbox_memcpy(&aq->sq, &rsp->sq, sizeof(rsp->sq));
360                 otx2_mbox_memset(&aq->sq_mask, 0, sizeof(aq->sq_mask));
361                 aq->sq.octs = 0;
362                 aq->sq.pkts = 0;
363                 aq->sq.drop_octs = 0;
364                 aq->sq.drop_pkts = 0;
365
366                 aq->sq_mask.octs = ~(aq->sq_mask.octs);
367                 aq->sq_mask.pkts = ~(aq->sq_mask.pkts);
368                 aq->sq_mask.drop_octs = ~(aq->sq_mask.drop_octs);
369                 aq->sq_mask.drop_pkts = ~(aq->sq_mask.drop_pkts);
370                 rc = otx2_mbox_process(mbox);
371                 if (rc) {
372                         otx2_err("Failed to write sq context");
373                         return rc;
374                 }
375         }
376
377         return 0;
378 }
379
380 int
381 otx2_nix_xstats_reset(struct rte_eth_dev *eth_dev)
382 {
383         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
384         struct otx2_mbox *mbox = dev->mbox;
385         int ret;
386
387         if (otx2_mbox_alloc_msg_nix_stats_rst(mbox) == NULL)
388                 return -ENOMEM;
389
390         ret = otx2_mbox_process(mbox);
391         if (ret != 0)
392                 return ret;
393
394         /* Reset queue stats */
395         return nix_queue_stats_reset(eth_dev);
396 }