replace alignment attributes
[dpdk.git] / drivers / net / octeontx2 / otx2_ethdev_ops.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(C) 2019 Marvell International Ltd.
3  */
4
5 #include <rte_ethdev.h>
6 #include <rte_mbuf_pool_ops.h>
7
8 #include "otx2_ethdev.h"
9
10 int
11 otx2_nix_mtu_set(struct rte_eth_dev *eth_dev, uint16_t mtu)
12 {
13         uint32_t buffsz, frame_size = mtu + NIX_L2_OVERHEAD;
14         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
15         struct rte_eth_dev_data *data = eth_dev->data;
16         struct otx2_mbox *mbox = dev->mbox;
17         struct nix_frs_cfg *req;
18         int rc;
19
20         frame_size += NIX_TIMESYNC_RX_OFFSET * otx2_ethdev_is_ptp_en(dev);
21
22         /* Check if MTU is within the allowed range */
23         if (frame_size < NIX_MIN_FRS || frame_size > NIX_MAX_FRS)
24                 return -EINVAL;
25
26         buffsz = data->min_rx_buf_size - RTE_PKTMBUF_HEADROOM;
27
28         /* Refuse MTU that requires the support of scattered packets
29          * when this feature has not been enabled before.
30          */
31         if (data->dev_started && frame_size > buffsz &&
32             !(dev->rx_offloads & DEV_RX_OFFLOAD_SCATTER))
33                 return -EINVAL;
34
35         /* Check <seg size> * <max_seg>  >= max_frame */
36         if ((dev->rx_offloads & DEV_RX_OFFLOAD_SCATTER) &&
37             (frame_size > buffsz * NIX_RX_NB_SEG_MAX))
38                 return -EINVAL;
39
40         req = otx2_mbox_alloc_msg_nix_set_hw_frs(mbox);
41         req->update_smq = true;
42         if (otx2_dev_is_sdp(dev))
43                 req->sdp_link = true;
44         /* FRS HW config should exclude FCS but include NPC VTAG insert size */
45         req->maxlen = frame_size - RTE_ETHER_CRC_LEN + NIX_MAX_VTAG_ACT_SIZE;
46
47         rc = otx2_mbox_process(mbox);
48         if (rc)
49                 return rc;
50
51         /* Now just update Rx MAXLEN */
52         req = otx2_mbox_alloc_msg_nix_set_hw_frs(mbox);
53         req->maxlen = frame_size - RTE_ETHER_CRC_LEN;
54         if (otx2_dev_is_sdp(dev))
55                 req->sdp_link = true;
56
57         rc = otx2_mbox_process(mbox);
58         if (rc)
59                 return rc;
60
61         if (frame_size > RTE_ETHER_MAX_LEN)
62                 dev->rx_offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME;
63         else
64                 dev->rx_offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME;
65
66         /* Update max_rx_pkt_len */
67         data->dev_conf.rxmode.max_rx_pkt_len = frame_size;
68
69         return rc;
70 }
71
72 int
73 otx2_nix_recalc_mtu(struct rte_eth_dev *eth_dev)
74 {
75         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
76         struct rte_eth_dev_data *data = eth_dev->data;
77         struct rte_pktmbuf_pool_private *mbp_priv;
78         struct otx2_eth_rxq *rxq;
79         uint32_t buffsz;
80         uint16_t mtu;
81         int rc;
82
83         /* Get rx buffer size */
84         rxq = data->rx_queues[0];
85         mbp_priv = rte_mempool_get_priv(rxq->pool);
86         buffsz = mbp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM;
87
88         /* Setup scatter mode if needed by jumbo */
89         if (data->dev_conf.rxmode.max_rx_pkt_len > buffsz)
90                 dev->rx_offloads |= DEV_RX_OFFLOAD_SCATTER;
91
92         /* Setup MTU based on max_rx_pkt_len */
93         mtu = data->dev_conf.rxmode.max_rx_pkt_len - NIX_L2_OVERHEAD;
94
95         rc = otx2_nix_mtu_set(eth_dev, mtu);
96         if (rc)
97                 otx2_err("Failed to set default MTU size %d", rc);
98
99         return rc;
100 }
101
102 static void
103 nix_cgx_promisc_config(struct rte_eth_dev *eth_dev, int en)
104 {
105         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
106         struct otx2_mbox *mbox = dev->mbox;
107
108         if (otx2_dev_is_vf_or_sdp(dev))
109                 return;
110
111         if (en)
112                 otx2_mbox_alloc_msg_cgx_promisc_enable(mbox);
113         else
114                 otx2_mbox_alloc_msg_cgx_promisc_disable(mbox);
115
116         otx2_mbox_process(mbox);
117 }
118
119 void
120 otx2_nix_promisc_config(struct rte_eth_dev *eth_dev, int en)
121 {
122         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
123         struct otx2_mbox *mbox = dev->mbox;
124         struct nix_rx_mode *req;
125
126         if (otx2_dev_is_vf(dev))
127                 return;
128
129         req = otx2_mbox_alloc_msg_nix_set_rx_mode(mbox);
130
131         if (en)
132                 req->mode = NIX_RX_MODE_UCAST | NIX_RX_MODE_PROMISC;
133
134         otx2_mbox_process(mbox);
135         eth_dev->data->promiscuous = en;
136         otx2_nix_vlan_update_promisc(eth_dev, en);
137 }
138
139 int
140 otx2_nix_promisc_enable(struct rte_eth_dev *eth_dev)
141 {
142         otx2_nix_promisc_config(eth_dev, 1);
143         nix_cgx_promisc_config(eth_dev, 1);
144
145         return 0;
146 }
147
148 int
149 otx2_nix_promisc_disable(struct rte_eth_dev *eth_dev)
150 {
151         otx2_nix_promisc_config(eth_dev, 0);
152         nix_cgx_promisc_config(eth_dev, 0);
153
154         return 0;
155 }
156
157 static void
158 nix_allmulticast_config(struct rte_eth_dev *eth_dev, int en)
159 {
160         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
161         struct otx2_mbox *mbox = dev->mbox;
162         struct nix_rx_mode *req;
163
164         if (otx2_dev_is_vf(dev))
165                 return;
166
167         req = otx2_mbox_alloc_msg_nix_set_rx_mode(mbox);
168
169         if (en)
170                 req->mode = NIX_RX_MODE_UCAST | NIX_RX_MODE_ALLMULTI;
171         else if (eth_dev->data->promiscuous)
172                 req->mode = NIX_RX_MODE_UCAST | NIX_RX_MODE_PROMISC;
173
174         otx2_mbox_process(mbox);
175 }
176
177 int
178 otx2_nix_allmulticast_enable(struct rte_eth_dev *eth_dev)
179 {
180         nix_allmulticast_config(eth_dev, 1);
181
182         return 0;
183 }
184
185 int
186 otx2_nix_allmulticast_disable(struct rte_eth_dev *eth_dev)
187 {
188         nix_allmulticast_config(eth_dev, 0);
189
190         return 0;
191 }
192
193 void
194 otx2_nix_rxq_info_get(struct rte_eth_dev *eth_dev, uint16_t queue_id,
195                       struct rte_eth_rxq_info *qinfo)
196 {
197         struct otx2_eth_rxq *rxq;
198
199         rxq = eth_dev->data->rx_queues[queue_id];
200
201         qinfo->mp = rxq->pool;
202         qinfo->scattered_rx = eth_dev->data->scattered_rx;
203         qinfo->nb_desc = rxq->qconf.nb_desc;
204
205         qinfo->conf.rx_free_thresh = 0;
206         qinfo->conf.rx_drop_en = 0;
207         qinfo->conf.rx_deferred_start = 0;
208         qinfo->conf.offloads = rxq->offloads;
209 }
210
211 void
212 otx2_nix_txq_info_get(struct rte_eth_dev *eth_dev, uint16_t queue_id,
213                       struct rte_eth_txq_info *qinfo)
214 {
215         struct otx2_eth_txq *txq;
216
217         txq = eth_dev->data->tx_queues[queue_id];
218
219         qinfo->nb_desc = txq->qconf.nb_desc;
220
221         qinfo->conf.tx_thresh.pthresh = 0;
222         qinfo->conf.tx_thresh.hthresh = 0;
223         qinfo->conf.tx_thresh.wthresh = 0;
224
225         qinfo->conf.tx_free_thresh = 0;
226         qinfo->conf.tx_rs_thresh = 0;
227         qinfo->conf.offloads = txq->offloads;
228         qinfo->conf.tx_deferred_start = 0;
229 }
230
231 int
232 otx2_rx_burst_mode_get(struct rte_eth_dev *eth_dev,
233                        __rte_unused uint16_t queue_id,
234                        struct rte_eth_burst_mode *mode)
235 {
236         ssize_t bytes = 0, str_size = RTE_ETH_BURST_MODE_INFO_SIZE, rc;
237         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
238         const struct burst_info {
239                 uint16_t flags;
240                 const char *output;
241         } rx_offload_map[] = {
242                         {NIX_RX_OFFLOAD_RSS_F, "RSS,"},
243                         {NIX_RX_OFFLOAD_PTYPE_F, " Ptype,"},
244                         {NIX_RX_OFFLOAD_CHECKSUM_F, " Checksum,"},
245                         {NIX_RX_OFFLOAD_VLAN_STRIP_F, " VLAN Strip,"},
246                         {NIX_RX_OFFLOAD_MARK_UPDATE_F, " Mark Update,"},
247                         {NIX_RX_OFFLOAD_TSTAMP_F, " Timestamp,"},
248                         {NIX_RX_MULTI_SEG_F, " Scattered,"}
249         };
250         static const char *const burst_mode[] = {"Vector Neon, Rx Offloads:",
251                                                  "Scalar, Rx Offloads:"
252         };
253         uint32_t i;
254
255         /* Update burst mode info */
256         rc = rte_strscpy(mode->info + bytes, burst_mode[dev->scalar_ena],
257                          str_size - bytes);
258         if (rc < 0)
259                 goto done;
260
261         bytes += rc;
262
263         /* Update Rx offload info */
264         for (i = 0; i < RTE_DIM(rx_offload_map); i++) {
265                 if (dev->rx_offload_flags & rx_offload_map[i].flags) {
266                         rc = rte_strscpy(mode->info + bytes,
267                                          rx_offload_map[i].output,
268                                          str_size - bytes);
269                         if (rc < 0)
270                                 goto done;
271
272                         bytes += rc;
273                 }
274         }
275
276 done:
277         return 0;
278 }
279
280 int
281 otx2_tx_burst_mode_get(struct rte_eth_dev *eth_dev,
282                        __rte_unused uint16_t queue_id,
283                        struct rte_eth_burst_mode *mode)
284 {
285         ssize_t bytes = 0, str_size = RTE_ETH_BURST_MODE_INFO_SIZE, rc;
286         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
287         const struct burst_info {
288                 uint16_t flags;
289                 const char *output;
290         } tx_offload_map[] = {
291                         {NIX_TX_OFFLOAD_L3_L4_CSUM_F, " Inner L3/L4 csum,"},
292                         {NIX_TX_OFFLOAD_OL3_OL4_CSUM_F, " Outer L3/L4 csum,"},
293                         {NIX_TX_OFFLOAD_VLAN_QINQ_F, " VLAN Insertion,"},
294                         {NIX_TX_OFFLOAD_MBUF_NOFF_F, " MBUF free disable,"},
295                         {NIX_TX_OFFLOAD_TSTAMP_F, " Timestamp,"},
296                         {NIX_TX_OFFLOAD_TSO_F, " TSO,"},
297                         {NIX_TX_MULTI_SEG_F, " Scattered,"}
298         };
299         static const char *const burst_mode[] = {"Vector Neon, Tx Offloads:",
300                                                  "Scalar, Tx Offloads:"
301         };
302         uint32_t i;
303
304         /* Update burst mode info */
305         rc = rte_strscpy(mode->info + bytes, burst_mode[dev->scalar_ena],
306                          str_size - bytes);
307         if (rc < 0)
308                 goto done;
309
310         bytes += rc;
311
312         /* Update Tx offload info */
313         for (i = 0; i < RTE_DIM(tx_offload_map); i++) {
314                 if (dev->tx_offload_flags & tx_offload_map[i].flags) {
315                         rc = rte_strscpy(mode->info + bytes,
316                                          tx_offload_map[i].output,
317                                          str_size - bytes);
318                         if (rc < 0)
319                                 goto done;
320
321                         bytes += rc;
322                 }
323         }
324
325 done:
326         return 0;
327 }
328
329 static void
330 nix_rx_head_tail_get(struct otx2_eth_dev *dev,
331                      uint32_t *head, uint32_t *tail, uint16_t queue_idx)
332 {
333         uint64_t reg, val;
334
335         if (head == NULL || tail == NULL)
336                 return;
337
338         reg = (((uint64_t)queue_idx) << 32);
339         val = otx2_atomic64_add_nosync(reg, (int64_t *)
340                                        (dev->base + NIX_LF_CQ_OP_STATUS));
341         if (val & (OP_ERR | CQ_ERR))
342                 val = 0;
343
344         *tail = (uint32_t)(val & 0xFFFFF);
345         *head = (uint32_t)((val >> 20) & 0xFFFFF);
346 }
347
348 uint32_t
349 otx2_nix_rx_queue_count(struct rte_eth_dev *eth_dev, uint16_t queue_idx)
350 {
351         struct otx2_eth_rxq *rxq = eth_dev->data->rx_queues[queue_idx];
352         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
353         uint32_t head, tail;
354
355         nix_rx_head_tail_get(dev, &head, &tail, queue_idx);
356         return (tail - head) % rxq->qlen;
357 }
358
359 static inline int
360 nix_offset_has_packet(uint32_t head, uint32_t tail, uint16_t offset)
361 {
362         /* Check given offset(queue index) has packet filled by HW */
363         if (tail > head && offset <= tail && offset >= head)
364                 return 1;
365         /* Wrap around case */
366         if (head > tail && (offset >= head || offset <= tail))
367                 return 1;
368
369         return 0;
370 }
371
372 int
373 otx2_nix_rx_descriptor_done(void *rx_queue, uint16_t offset)
374 {
375         struct otx2_eth_rxq *rxq = rx_queue;
376         uint32_t head, tail;
377
378         nix_rx_head_tail_get(otx2_eth_pmd_priv(rxq->eth_dev),
379                              &head, &tail, rxq->rq);
380
381         return nix_offset_has_packet(head, tail, offset);
382 }
383
384 int
385 otx2_nix_rx_descriptor_status(void *rx_queue, uint16_t offset)
386 {
387         struct otx2_eth_rxq *rxq = rx_queue;
388         uint32_t head, tail;
389
390         if (rxq->qlen <= offset)
391                 return -EINVAL;
392
393         nix_rx_head_tail_get(otx2_eth_pmd_priv(rxq->eth_dev),
394                              &head, &tail, rxq->rq);
395
396         if (nix_offset_has_packet(head, tail, offset))
397                 return RTE_ETH_RX_DESC_DONE;
398         else
399                 return RTE_ETH_RX_DESC_AVAIL;
400 }
401
402 static void
403 nix_tx_head_tail_get(struct otx2_eth_dev *dev,
404                      uint32_t *head, uint32_t *tail, uint16_t queue_idx)
405 {
406         uint64_t reg, val;
407
408         if (head == NULL || tail == NULL)
409                 return;
410
411         reg = (((uint64_t)queue_idx) << 32);
412         val = otx2_atomic64_add_nosync(reg, (int64_t *)
413                                        (dev->base + NIX_LF_SQ_OP_STATUS));
414         if (val & OP_ERR)
415                 val = 0;
416
417         *tail = (uint32_t)((val >> 28) & 0x3F);
418         *head = (uint32_t)((val >> 20) & 0x3F);
419 }
420
421 int
422 otx2_nix_tx_descriptor_status(void *tx_queue, uint16_t offset)
423 {
424         struct otx2_eth_txq *txq = tx_queue;
425         uint32_t head, tail;
426
427         if (txq->qconf.nb_desc <= offset)
428                 return -EINVAL;
429
430         nix_tx_head_tail_get(txq->dev, &head, &tail, txq->sq);
431
432         if (nix_offset_has_packet(head, tail, offset))
433                 return RTE_ETH_TX_DESC_DONE;
434         else
435                 return RTE_ETH_TX_DESC_FULL;
436 }
437
438 /* It is a NOP for octeontx2 as HW frees the buffer on xmit */
439 int
440 otx2_nix_tx_done_cleanup(void *txq, uint32_t free_cnt)
441 {
442         RTE_SET_USED(txq);
443         RTE_SET_USED(free_cnt);
444
445         return 0;
446 }
447
448 int
449 otx2_nix_fw_version_get(struct rte_eth_dev *eth_dev, char *fw_version,
450                         size_t fw_size)
451 {
452         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
453         int rc = (int)fw_size;
454
455         if (fw_size > sizeof(dev->mkex_pfl_name))
456                 rc = sizeof(dev->mkex_pfl_name);
457
458         rc = strlcpy(fw_version, (char *)dev->mkex_pfl_name, rc);
459
460         rc += 1; /* Add the size of '\0' */
461         if (fw_size < (uint32_t)rc)
462                 return rc;
463
464         return 0;
465 }
466
467 int
468 otx2_nix_pool_ops_supported(struct rte_eth_dev *eth_dev, const char *pool)
469 {
470         RTE_SET_USED(eth_dev);
471
472         if (!strcmp(pool, rte_mbuf_platform_mempool_ops()))
473                 return 0;
474
475         return -ENOTSUP;
476 }
477
478 int
479 otx2_nix_dev_filter_ctrl(struct rte_eth_dev *eth_dev,
480                          enum rte_filter_type filter_type,
481                          enum rte_filter_op filter_op, void *arg)
482 {
483         RTE_SET_USED(eth_dev);
484
485         if (filter_type != RTE_ETH_FILTER_GENERIC) {
486                 otx2_err("Unsupported filter type %d", filter_type);
487                 return -ENOTSUP;
488         }
489
490         if (filter_op == RTE_ETH_FILTER_GET) {
491                 *(const void **)arg = &otx2_flow_ops;
492                 return 0;
493         }
494
495         otx2_err("Invalid filter_op %d", filter_op);
496         return -EINVAL;
497 }
498
499 static struct cgx_fw_data *
500 nix_get_fwdata(struct otx2_eth_dev *dev)
501 {
502         struct otx2_mbox *mbox = dev->mbox;
503         struct cgx_fw_data *rsp = NULL;
504         int rc;
505
506         otx2_mbox_alloc_msg_cgx_get_aux_link_info(mbox);
507
508         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
509         if (rc) {
510                 otx2_err("Failed to get fw data: %d", rc);
511                 return NULL;
512         }
513
514         return rsp;
515 }
516
517 int
518 otx2_nix_get_module_info(struct rte_eth_dev *eth_dev,
519                          struct rte_eth_dev_module_info *modinfo)
520 {
521         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
522         struct cgx_fw_data *rsp;
523
524         rsp = nix_get_fwdata(dev);
525         if (rsp == NULL)
526                 return -EIO;
527
528         modinfo->type = rsp->fwdata.sfp_eeprom.sff_id;
529         modinfo->eeprom_len = SFP_EEPROM_SIZE;
530
531         return 0;
532 }
533
534 int
535 otx2_nix_get_module_eeprom(struct rte_eth_dev *eth_dev,
536                            struct rte_dev_eeprom_info *info)
537 {
538         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
539         struct cgx_fw_data *rsp;
540
541         if (!info->data || !info->length ||
542             (info->offset + info->length > SFP_EEPROM_SIZE))
543                 return -EINVAL;
544
545         rsp = nix_get_fwdata(dev);
546         if (rsp == NULL)
547                 return -EIO;
548
549         otx2_mbox_memcpy(info->data, rsp->fwdata.sfp_eeprom.buf + info->offset,
550                          info->length);
551
552         return 0;
553 }
554
555 int
556 otx2_nix_info_get(struct rte_eth_dev *eth_dev, struct rte_eth_dev_info *devinfo)
557 {
558         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
559         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
560
561         devinfo->min_rx_bufsize = NIX_MIN_FRS;
562         devinfo->max_rx_pktlen = NIX_MAX_FRS;
563         devinfo->max_rx_queues = RTE_MAX_QUEUES_PER_PORT;
564         devinfo->max_tx_queues = RTE_MAX_QUEUES_PER_PORT;
565         devinfo->max_mac_addrs = dev->max_mac_entries;
566         devinfo->max_vfs = pci_dev->max_vfs;
567         devinfo->max_mtu = devinfo->max_rx_pktlen - NIX_L2_OVERHEAD;
568         devinfo->min_mtu = devinfo->min_rx_bufsize - NIX_L2_OVERHEAD;
569
570         devinfo->rx_offload_capa = dev->rx_offload_capa;
571         devinfo->tx_offload_capa = dev->tx_offload_capa;
572         devinfo->rx_queue_offload_capa = 0;
573         devinfo->tx_queue_offload_capa = 0;
574
575         devinfo->reta_size = dev->rss_info.rss_size;
576         devinfo->hash_key_size = NIX_HASH_KEY_SIZE;
577         devinfo->flow_type_rss_offloads = NIX_RSS_OFFLOAD;
578
579         devinfo->default_rxconf = (struct rte_eth_rxconf) {
580                 .rx_drop_en = 0,
581                 .offloads = 0,
582         };
583
584         devinfo->default_txconf = (struct rte_eth_txconf) {
585                 .offloads = 0,
586         };
587
588         devinfo->default_rxportconf = (struct rte_eth_dev_portconf) {
589                 .ring_size = NIX_RX_DEFAULT_RING_SZ,
590         };
591
592         devinfo->rx_desc_lim = (struct rte_eth_desc_lim) {
593                 .nb_max = UINT16_MAX,
594                 .nb_min = NIX_RX_MIN_DESC,
595                 .nb_align = NIX_RX_MIN_DESC_ALIGN,
596                 .nb_seg_max = NIX_RX_NB_SEG_MAX,
597                 .nb_mtu_seg_max = NIX_RX_NB_SEG_MAX,
598         };
599         devinfo->rx_desc_lim.nb_max =
600                 RTE_ALIGN_MUL_FLOOR(devinfo->rx_desc_lim.nb_max,
601                                     NIX_RX_MIN_DESC_ALIGN);
602
603         devinfo->tx_desc_lim = (struct rte_eth_desc_lim) {
604                 .nb_max = UINT16_MAX,
605                 .nb_min = 1,
606                 .nb_align = 1,
607                 .nb_seg_max = NIX_TX_NB_SEG_MAX,
608                 .nb_mtu_seg_max = NIX_TX_NB_SEG_MAX,
609         };
610
611         /* Auto negotiation disabled */
612         devinfo->speed_capa = ETH_LINK_SPEED_FIXED;
613         devinfo->speed_capa |= ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G |
614                                 ETH_LINK_SPEED_25G | ETH_LINK_SPEED_40G |
615                                 ETH_LINK_SPEED_50G | ETH_LINK_SPEED_100G;
616
617         devinfo->dev_capa = RTE_ETH_DEV_CAPA_RUNTIME_RX_QUEUE_SETUP |
618                                 RTE_ETH_DEV_CAPA_RUNTIME_TX_QUEUE_SETUP;
619
620         return 0;
621 }