1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Marvell International Ltd.
3 * Copyright(c) 2018 Semihalf.
4 * All rights reserved.
5 */
6
7 #include <rte_string_fns.h>
8 #include <ethdev_driver.h>
9 #include <rte_kvargs.h>
10 #include <rte_bus_vdev.h>
11
12 #include <stdio.h>
13 #include <fcntl.h>
14 #include <linux/ethtool.h>
15 #include <linux/sockios.h>
16 #include <net/if.h>
17 #include <net/if_arp.h>
18 #include <sys/ioctl.h>
19 #include <sys/socket.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22
23 #include <rte_mvep_common.h>
24
25 #include "mvneta_rxtx.h"
26
27
28 #define MVNETA_IFACE_NAME_ARG "iface"
29
30 #define MVNETA_PKT_SIZE_MAX (16382 - MV_MH_SIZE) /* 9700B */
31 #define MVNETA_DEFAULT_MTU 1500
32
33 #define MVNETA_MAC_ADDRS_MAX 256 /*16 UC, 256 IP, 256 MC/BC */
34 /** Maximum length of a match string */
35 #define MVNETA_MATCH_LEN 16
36
37 static const char * const valid_args[] = {
38 MVNETA_IFACE_NAME_ARG,
39 NULL
40 };
41
42 struct mvneta_ifnames {
43 const char *names[NETA_NUM_ETH_PPIO];
44 int idx;
45 };
46
47 static int mvneta_dev_num;
48
49 static int mvneta_stats_reset(struct rte_eth_dev *dev);
50 static int rte_pmd_mvneta_remove(struct rte_vdev_device *vdev);
51
52
53 /**
54 * Deinitialize packet processor.
55 */
56 static void
mvneta_neta_deinit(void)57 mvneta_neta_deinit(void)
58 {
59 neta_deinit();
60 }
61
62 /**
63 * Initialize packet processor.
64 *
65 * @return
66 * 0 on success, negative error value otherwise.
67 */
68 static int
mvneta_neta_init(void)69 mvneta_neta_init(void)
70 {
71 return neta_init();
72 }
73
74 /**
75 * Callback used by rte_kvargs_process() during argument parsing.
76 *
77 * @param key
78 * Pointer to the parsed key (unused).
79 * @param value
80 * Pointer to the parsed value.
81 * @param extra_args
82 * Pointer to the extra arguments which contains address of the
83 * table of pointers to parsed interface names.
84 *
85 * @return
86 * Always 0.
87 */
88 static int
mvneta_ifnames_get(const char * key __rte_unused,const char * value,void * extra_args)89 mvneta_ifnames_get(const char *key __rte_unused, const char *value,
90 void *extra_args)
91 {
92 struct mvneta_ifnames *ifnames = extra_args;
93
94 ifnames->names[ifnames->idx++] = value;
95
96 return 0;
97 }
98
99 /**
100 * Ethernet device configuration.
101 *
102 * Prepare the driver for a given number of TX and RX queues and
103 * configure RSS if supported.
104 *
105 * @param dev
106 * Pointer to Ethernet device structure.
107 *
108 * @return
109 * 0 on success, negative error value otherwise.
110 */
111 static int
mvneta_dev_configure(struct rte_eth_dev * dev)112 mvneta_dev_configure(struct rte_eth_dev *dev)
113 {
114 struct mvneta_priv *priv = dev->data->dev_private;
115 struct neta_ppio_params *ppio_params;
116
117 if (dev->data->dev_conf.rxmode.mq_mode != RTE_ETH_MQ_RX_NONE) {
118 MVNETA_LOG(INFO, "Unsupported RSS and rx multi queue mode %d",
119 dev->data->dev_conf.rxmode.mq_mode);
120 if (dev->data->nb_rx_queues > 1)
121 return -EINVAL;
122 }
123
124 if (dev->data->dev_conf.rxmode.split_hdr_size) {
125 MVNETA_LOG(INFO, "Split headers not supported");
126 return -EINVAL;
127 }
128
129 if (dev->data->dev_conf.txmode.offloads & RTE_ETH_TX_OFFLOAD_MULTI_SEGS)
130 priv->multiseg = 1;
131
132 ppio_params = &priv->ppio_params;
133 ppio_params->outqs_params.num_outqs = dev->data->nb_tx_queues;
134 /* Default: 1 TC, no QoS supported. */
135 ppio_params->inqs_params.num_tcs = 1;
136 ppio_params->inqs_params.tcs_params[0].pkt_offset = MRVL_NETA_PKT_OFFS;
137 priv->ppio_id = dev->data->port_id;
138
139 return 0;
140 }
141
142 /**
143 * DPDK callback to get information about the device.
144 *
145 * @param dev
146 * Pointer to Ethernet device structure (unused).
147 * @param info
148 * Info structure output buffer.
149 */
150 static int
mvneta_dev_infos_get(struct rte_eth_dev * dev __rte_unused,struct rte_eth_dev_info * info)151 mvneta_dev_infos_get(struct rte_eth_dev *dev __rte_unused,
152 struct rte_eth_dev_info *info)
153 {
154 info->speed_capa = RTE_ETH_LINK_SPEED_10M |
155 RTE_ETH_LINK_SPEED_100M |
156 RTE_ETH_LINK_SPEED_1G |
157 RTE_ETH_LINK_SPEED_2_5G;
158
159 info->max_rx_queues = MRVL_NETA_RXQ_MAX;
160 info->max_tx_queues = MRVL_NETA_TXQ_MAX;
161 info->max_mac_addrs = MVNETA_MAC_ADDRS_MAX;
162
163 info->rx_desc_lim.nb_max = MRVL_NETA_RXD_MAX;
164 info->rx_desc_lim.nb_min = MRVL_NETA_RXD_MIN;
165 info->rx_desc_lim.nb_align = MRVL_NETA_RXD_ALIGN;
166
167 info->tx_desc_lim.nb_max = MRVL_NETA_TXD_MAX;
168 info->tx_desc_lim.nb_min = MRVL_NETA_TXD_MIN;
169 info->tx_desc_lim.nb_align = MRVL_NETA_TXD_ALIGN;
170
171 info->rx_offload_capa = MVNETA_RX_OFFLOADS;
172 info->rx_queue_offload_capa = MVNETA_RX_OFFLOADS;
173
174 info->tx_offload_capa = MVNETA_TX_OFFLOADS;
175 info->tx_queue_offload_capa = MVNETA_TX_OFFLOADS;
176
177 /* By default packets are dropped if no descriptors are available */
178 info->default_rxconf.rx_drop_en = 1;
179 /* Deferred tx queue start is not supported */
180 info->default_txconf.tx_deferred_start = 0;
181 info->default_txconf.offloads = 0;
182
183 info->max_rx_pktlen = MVNETA_PKT_SIZE_MAX;
184
185 return 0;
186 }
187
188 /**
189 * Return supported packet types.
190 *
191 * @param dev
192 * Pointer to Ethernet device structure (unused).
193 *
194 * @return
195 * Const pointer to the table with supported packet types.
196 */
197 static const uint32_t *
mvneta_dev_supported_ptypes_get(struct rte_eth_dev * dev __rte_unused)198 mvneta_dev_supported_ptypes_get(struct rte_eth_dev *dev __rte_unused)
199 {
200 static const uint32_t ptypes[] = {
201 RTE_PTYPE_L2_ETHER,
202 RTE_PTYPE_L2_ETHER_VLAN,
203 RTE_PTYPE_L3_IPV4,
204 RTE_PTYPE_L3_IPV6,
205 RTE_PTYPE_L4_TCP,
206 RTE_PTYPE_L4_UDP
207 };
208
209 return ptypes;
210 }
211
212 /**
213 * DPDK callback to change the MTU.
214 *
215 * Setting the MTU affects hardware MRU (packets larger than the MRU
216 * will be dropped).
217 *
218 * @param dev
219 * Pointer to Ethernet device structure.
220 * @param mtu
221 * New MTU.
222 *
223 * @return
224 * 0 on success, negative error value otherwise.
225 */
226 static int
mvneta_mtu_set(struct rte_eth_dev * dev,uint16_t mtu)227 mvneta_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
228 {
229 struct mvneta_priv *priv = dev->data->dev_private;
230 uint16_t mbuf_data_size = 0; /* SW buffer size */
231 uint16_t mru;
232 int ret;
233
234 mru = MRVL_NETA_MTU_TO_MRU(mtu);
235 /*
236 * min_rx_buf_size is equal to mbuf data size
237 * if pmd didn't set it differently
238 */
239 mbuf_data_size = dev->data->min_rx_buf_size - RTE_PKTMBUF_HEADROOM;
240 /* Prevent PMD from:
241 * - setting mru greater than the mbuf size resulting in
242 * hw and sw buffer size mismatch
243 * - setting mtu that requires the support of scattered packets
244 * when this feature has not been enabled/supported so far.
245 */
246 if (!dev->data->scattered_rx &&
247 (mru + MRVL_NETA_PKT_OFFS > mbuf_data_size)) {
248 mru = mbuf_data_size - MRVL_NETA_PKT_OFFS;
249 mtu = MRVL_NETA_MRU_TO_MTU(mru);
250 MVNETA_LOG(WARNING, "MTU too big, max MTU possible limited by"
251 " current mbuf size: %u. Set MTU to %u, MRU to %u",
252 mbuf_data_size, mtu, mru);
253 }
254
255 if (mtu < RTE_ETHER_MIN_MTU || mru > MVNETA_PKT_SIZE_MAX) {
256 MVNETA_LOG(ERR, "Invalid MTU [%u] or MRU [%u]", mtu, mru);
257 return -EINVAL;
258 }
259
260 if (!priv->ppio)
261 /* It is OK. New MTU will be set later on mvneta_dev_start */
262 return 0;
263
264 ret = neta_ppio_set_mru(priv->ppio, mru);
265 if (ret) {
266 MVNETA_LOG(ERR, "Failed to change MRU");
267 return ret;
268 }
269
270 ret = neta_ppio_set_mtu(priv->ppio, mtu);
271 if (ret) {
272 MVNETA_LOG(ERR, "Failed to change MTU");
273 return ret;
274 }
275 MVNETA_LOG(INFO, "MTU changed to %u, MRU = %u", mtu, mru);
276
277 return 0;
278 }
279
280 /**
281 * DPDK callback to bring the link up.
282 *
283 * @param dev
284 * Pointer to Ethernet device structure.
285 *
286 * @return
287 * 0 on success, negative error value otherwise.
288 */
289 static int
mvneta_dev_set_link_up(struct rte_eth_dev * dev)290 mvneta_dev_set_link_up(struct rte_eth_dev *dev)
291 {
292 struct mvneta_priv *priv = dev->data->dev_private;
293
294 if (!priv->ppio)
295 return 0;
296
297 return neta_ppio_enable(priv->ppio);
298 }
299
300 /**
301 * DPDK callback to bring the link down.
302 *
303 * @param dev
304 * Pointer to Ethernet device structure.
305 *
306 * @return
307 * 0 on success, negative error value otherwise.
308 */
309 static int
mvneta_dev_set_link_down(struct rte_eth_dev * dev)310 mvneta_dev_set_link_down(struct rte_eth_dev *dev)
311 {
312 struct mvneta_priv *priv = dev->data->dev_private;
313
314 if (!priv->ppio)
315 return 0;
316
317 return neta_ppio_disable(priv->ppio);
318 }
319
320 /**
321 * DPDK callback to start the device.
322 *
323 * @param dev
324 * Pointer to Ethernet device structure.
325 *
326 * @return
327 * 0 on success, negative errno value on failure.
328 */
329 static int
mvneta_dev_start(struct rte_eth_dev * dev)330 mvneta_dev_start(struct rte_eth_dev *dev)
331 {
332 struct mvneta_priv *priv = dev->data->dev_private;
333 char match[MVNETA_MATCH_LEN];
334 int ret = 0, i;
335
336 if (priv->ppio)
337 return mvneta_dev_set_link_up(dev);
338
339 strlcpy(match, dev->data->name, sizeof(match));
340 priv->ppio_params.match = match;
341 priv->ppio_params.inqs_params.mtu = dev->data->mtu;
342
343 ret = neta_ppio_init(&priv->ppio_params, &priv->ppio);
344 if (ret) {
345 MVNETA_LOG(ERR, "Failed to init ppio");
346 return ret;
347 }
348 priv->ppio_id = priv->ppio->port_id;
349
350 mvneta_stats_reset(dev);
351
352 /*
353 * In case there are some some stale uc/mc mac addresses flush them
354 * here. It cannot be done during mvneta_dev_close() as port information
355 * is already gone at that point (due to neta_ppio_deinit() in
356 * mvneta_dev_stop()).
357 */
358 if (!priv->uc_mc_flushed) {
359 ret = neta_ppio_flush_mac_addrs(priv->ppio, 0, 1);
360 if (ret) {
361 MVNETA_LOG(ERR,
362 "Failed to flush uc/mc filter list");
363 goto out;
364 }
365 priv->uc_mc_flushed = 1;
366 }
367
368 ret = mvneta_alloc_rx_bufs(dev);
369 if (ret)
370 goto out;
371
372 ret = mvneta_mtu_set(dev, dev->data->mtu);
373 if (ret) {
374 MVNETA_LOG(ERR, "Failed to set MTU %d", dev->data->mtu);
375 goto out;
376 }
377
378 ret = mvneta_dev_set_link_up(dev);
379 if (ret) {
380 MVNETA_LOG(ERR, "Failed to set link up");
381 goto out;
382 }
383
384 /* start tx queues */
385 for (i = 0; i < dev->data->nb_tx_queues; i++)
386 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
387
388 mvneta_set_tx_function(dev);
389
390 return 0;
391
392 out:
393 MVNETA_LOG(ERR, "Failed to start device");
394 neta_ppio_deinit(priv->ppio);
395 return ret;
396 }
397
398 /**
399 * DPDK callback to stop the device.
400 *
401 * @param dev
402 * Pointer to Ethernet device structure.
403 */
404 static int
mvneta_dev_stop(struct rte_eth_dev * dev)405 mvneta_dev_stop(struct rte_eth_dev *dev)
406 {
407 struct mvneta_priv *priv = dev->data->dev_private;
408
409 dev->data->dev_started = 0;
410
411 if (!priv->ppio)
412 return 0;
413
414 mvneta_dev_set_link_down(dev);
415 mvneta_flush_queues(dev);
416 neta_ppio_deinit(priv->ppio);
417
418 priv->ppio = NULL;
419
420 return 0;
421 }
422
423 /**
424 * DPDK callback to close the device.
425 *
426 * @param dev
427 * Pointer to Ethernet device structure.
428 */
429 static int
mvneta_dev_close(struct rte_eth_dev * dev)430 mvneta_dev_close(struct rte_eth_dev *dev)
431 {
432 struct mvneta_priv *priv = dev->data->dev_private;
433 int i, ret = 0;
434
435 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
436 return 0;
437
438 if (priv->ppio)
439 ret = mvneta_dev_stop(dev);
440
441 for (i = 0; i < dev->data->nb_rx_queues; i++) {
442 mvneta_rx_queue_release(dev, i);
443 dev->data->rx_queues[i] = NULL;
444 }
445
446 for (i = 0; i < dev->data->nb_tx_queues; i++) {
447 mvneta_tx_queue_release(dev, i);
448 dev->data->tx_queues[i] = NULL;
449 }
450
451 mvneta_dev_num--;
452
453 if (mvneta_dev_num == 0) {
454 MVNETA_LOG(INFO, "Perform MUSDK deinit");
455 mvneta_neta_deinit();
456 rte_mvep_deinit(MVEP_MOD_T_NETA);
457 }
458
459 return ret;
460 }
461
462 /**
463 * DPDK callback to retrieve physical link information.
464 *
465 * @param dev
466 * Pointer to Ethernet device structure.
467 * @param wait_to_complete
468 * Wait for request completion (ignored).
469 *
470 * @return
471 * 0 on success, negative error value otherwise.
472 */
473 static int
mvneta_link_update(struct rte_eth_dev * dev,int wait_to_complete __rte_unused)474 mvneta_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
475 {
476 /*
477 * TODO
478 * once MUSDK provides necessary API use it here
479 */
480 struct mvneta_priv *priv = dev->data->dev_private;
481 struct ethtool_cmd edata;
482 struct ifreq req;
483 int ret, fd, link_up;
484
485 if (!priv->ppio)
486 return -EPERM;
487
488 edata.cmd = ETHTOOL_GSET;
489
490 strcpy(req.ifr_name, dev->data->name);
491 req.ifr_data = (void *)&edata;
492
493 fd = socket(AF_INET, SOCK_DGRAM, 0);
494 if (fd == -1)
495 return -EFAULT;
496 ret = ioctl(fd, SIOCETHTOOL, &req);
497 if (ret == -1) {
498 close(fd);
499 return -EFAULT;
500 }
501
502 close(fd);
503
504 switch (ethtool_cmd_speed(&edata)) {
505 case SPEED_10:
506 dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_10M;
507 break;
508 case SPEED_100:
509 dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_100M;
510 break;
511 case SPEED_1000:
512 dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_1G;
513 break;
514 case SPEED_2500:
515 dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_2_5G;
516 break;
517 default:
518 dev->data->dev_link.link_speed = RTE_ETH_SPEED_NUM_NONE;
519 }
520
521 dev->data->dev_link.link_duplex = edata.duplex ? RTE_ETH_LINK_FULL_DUPLEX :
522 RTE_ETH_LINK_HALF_DUPLEX;
523 dev->data->dev_link.link_autoneg = edata.autoneg ? RTE_ETH_LINK_AUTONEG :
524 RTE_ETH_LINK_FIXED;
525
526 neta_ppio_get_link_state(priv->ppio, &link_up);
527 dev->data->dev_link.link_status = link_up ? RTE_ETH_LINK_UP : RTE_ETH_LINK_DOWN;
528
529 return 0;
530 }
531
532 /**
533 * DPDK callback to enable promiscuous mode.
534 *
535 * @param dev
536 * Pointer to Ethernet device structure.
537 *
538 * @return
539 * always 0
540 */
541 static int
mvneta_promiscuous_enable(struct rte_eth_dev * dev)542 mvneta_promiscuous_enable(struct rte_eth_dev *dev)
543 {
544 struct mvneta_priv *priv = dev->data->dev_private;
545 int ret, en;
546
547 if (!priv->ppio)
548 return 0;
549
550 neta_ppio_get_promisc(priv->ppio, &en);
551 if (en) {
552 MVNETA_LOG(INFO, "Promiscuous already enabled");
553 return 0;
554 }
555
556 ret = neta_ppio_set_promisc(priv->ppio, 1);
557 if (ret)
558 MVNETA_LOG(ERR, "Failed to enable promiscuous mode");
559
560 return 0;
561 }
562
563 /**
564 * DPDK callback to disable allmulticast mode.
565 *
566 * @param dev
567 * Pointer to Ethernet device structure.
568 *
569 * @return
570 * always 0
571 */
572 static int
mvneta_promiscuous_disable(struct rte_eth_dev * dev)573 mvneta_promiscuous_disable(struct rte_eth_dev *dev)
574 {
575 struct mvneta_priv *priv = dev->data->dev_private;
576 int ret, en;
577
578 if (!priv->ppio)
579 return 0;
580
581 neta_ppio_get_promisc(priv->ppio, &en);
582 if (!en) {
583 MVNETA_LOG(INFO, "Promiscuous already disabled");
584 return 0;
585 }
586
587 ret = neta_ppio_set_promisc(priv->ppio, 0);
588 if (ret)
589 MVNETA_LOG(ERR, "Failed to disable promiscuous mode");
590
591 return 0;
592 }
593
594 /**
595 * DPDK callback to remove a MAC address.
596 *
597 * @param dev
598 * Pointer to Ethernet device structure.
599 * @param index
600 * MAC address index.
601 */
602 static void
mvneta_mac_addr_remove(struct rte_eth_dev * dev,uint32_t index)603 mvneta_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
604 {
605 struct mvneta_priv *priv = dev->data->dev_private;
606 char buf[RTE_ETHER_ADDR_FMT_SIZE];
607 int ret;
608
609 if (!priv->ppio)
610 return;
611
612 ret = neta_ppio_remove_mac_addr(priv->ppio,
613 dev->data->mac_addrs[index].addr_bytes);
614 if (ret) {
615 rte_ether_format_addr(buf, sizeof(buf),
616 &dev->data->mac_addrs[index]);
617 MVNETA_LOG(ERR, "Failed to remove mac %s", buf);
618 }
619 }
620
621 /**
622 * DPDK callback to add a MAC address.
623 *
624 * @param dev
625 * Pointer to Ethernet device structure.
626 * @param mac_addr
627 * MAC address to register.
628 * @param index
629 * MAC address index.
630 * @param vmdq
631 * VMDq pool index to associate address with (unused).
632 *
633 * @return
634 * 0 on success, negative error value otherwise.
635 */
636 static int
mvneta_mac_addr_add(struct rte_eth_dev * dev,struct rte_ether_addr * mac_addr,uint32_t index,uint32_t vmdq __rte_unused)637 mvneta_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
638 uint32_t index, uint32_t vmdq __rte_unused)
639 {
640 struct mvneta_priv *priv = dev->data->dev_private;
641 char buf[RTE_ETHER_ADDR_FMT_SIZE];
642 int ret;
643
644 if (index == 0)
645 /* For setting index 0, mrvl_mac_addr_set() should be used.*/
646 return -1;
647
648 if (!priv->ppio)
649 return 0;
650
651 ret = neta_ppio_add_mac_addr(priv->ppio, mac_addr->addr_bytes);
652 if (ret) {
653 rte_ether_format_addr(buf, sizeof(buf), mac_addr);
654 MVNETA_LOG(ERR, "Failed to add mac %s", buf);
655 return -1;
656 }
657
658 return 0;
659 }
660
661 /**
662 * DPDK callback to set the primary MAC address.
663 *
664 * @param dev
665 * Pointer to Ethernet device structure.
666 * @param mac_addr
667 * MAC address to register.
668 */
669 static int
mvneta_mac_addr_set(struct rte_eth_dev * dev,struct rte_ether_addr * mac_addr)670 mvneta_mac_addr_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
671 {
672 struct mvneta_priv *priv = dev->data->dev_private;
673 int ret;
674
675 if (!priv->ppio)
676 return -EINVAL;
677
678 ret = neta_ppio_set_mac_addr(priv->ppio, mac_addr->addr_bytes);
679 if (ret) {
680 char buf[RTE_ETHER_ADDR_FMT_SIZE];
681 rte_ether_format_addr(buf, sizeof(buf), mac_addr);
682 MVNETA_LOG(ERR, "Failed to set mac to %s", buf);
683 }
684 return 0;
685 }
686
687 /**
688 * DPDK callback to get device statistics.
689 *
690 * @param dev
691 * Pointer to Ethernet device structure.
692 * @param stats
693 * Stats structure output buffer.
694 *
695 * @return
696 * 0 on success, negative error value otherwise.
697 */
698 static int
mvneta_stats_get(struct rte_eth_dev * dev,struct rte_eth_stats * stats)699 mvneta_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
700 {
701 struct mvneta_priv *priv = dev->data->dev_private;
702 struct neta_ppio_statistics ppio_stats;
703 unsigned int ret;
704
705 if (!priv->ppio)
706 return -EPERM;
707
708 ret = neta_ppio_get_statistics(priv->ppio, &ppio_stats);
709 if (unlikely(ret)) {
710 MVNETA_LOG(ERR, "Failed to update port statistics");
711 return ret;
712 }
713
714 stats->ipackets += ppio_stats.rx_packets +
715 ppio_stats.rx_broadcast_packets +
716 ppio_stats.rx_multicast_packets -
717 priv->prev_stats.ipackets;
718 stats->opackets += ppio_stats.tx_packets +
719 ppio_stats.tx_broadcast_packets +
720 ppio_stats.tx_multicast_packets -
721 priv->prev_stats.opackets;
722 stats->ibytes += ppio_stats.rx_bytes - priv->prev_stats.ibytes;
723 stats->obytes += ppio_stats.tx_bytes - priv->prev_stats.obytes;
724 stats->imissed += ppio_stats.rx_discard +
725 ppio_stats.rx_overrun -
726 priv->prev_stats.imissed;
727 stats->ierrors = ppio_stats.rx_packets_err -
728 priv->prev_stats.ierrors;
729 stats->oerrors = ppio_stats.tx_errors - priv->prev_stats.oerrors;
730
731 return 0;
732 }
733
734 /**
735 * DPDK callback to clear device statistics.
736 *
737 * @param dev
738 * Pointer to Ethernet device structure.
739 *
740 * @return
741 * 0 on success, negative error value otherwise.
742 */
743 static int
mvneta_stats_reset(struct rte_eth_dev * dev)744 mvneta_stats_reset(struct rte_eth_dev *dev)
745 {
746 struct mvneta_priv *priv = dev->data->dev_private;
747 unsigned int ret;
748
749 if (!priv->ppio)
750 return 0;
751
752 ret = mvneta_stats_get(dev, &priv->prev_stats);
753 if (unlikely(ret))
754 MVNETA_LOG(ERR, "Failed to reset port statistics");
755
756 return ret;
757 }
758
759
760 static const struct eth_dev_ops mvneta_ops = {
761 .dev_configure = mvneta_dev_configure,
762 .dev_start = mvneta_dev_start,
763 .dev_stop = mvneta_dev_stop,
764 .dev_set_link_up = mvneta_dev_set_link_up,
765 .dev_set_link_down = mvneta_dev_set_link_down,
766 .dev_close = mvneta_dev_close,
767 .link_update = mvneta_link_update,
768 .promiscuous_enable = mvneta_promiscuous_enable,
769 .promiscuous_disable = mvneta_promiscuous_disable,
770 .mac_addr_remove = mvneta_mac_addr_remove,
771 .mac_addr_add = mvneta_mac_addr_add,
772 .mac_addr_set = mvneta_mac_addr_set,
773 .mtu_set = mvneta_mtu_set,
774 .stats_get = mvneta_stats_get,
775 .stats_reset = mvneta_stats_reset,
776 .dev_infos_get = mvneta_dev_infos_get,
777 .dev_supported_ptypes_get = mvneta_dev_supported_ptypes_get,
778 .rxq_info_get = mvneta_rxq_info_get,
779 .txq_info_get = mvneta_txq_info_get,
780 .rx_queue_setup = mvneta_rx_queue_setup,
781 .rx_queue_release = mvneta_rx_queue_release,
782 .tx_queue_setup = mvneta_tx_queue_setup,
783 .tx_queue_release = mvneta_tx_queue_release,
784 };
785
786 /**
787 * Create device representing Ethernet port.
788 *
789 * @param name
790 * Pointer to the port's name.
791 *
792 * @return
793 * 0 on success, negative error value otherwise.
794 */
795 static int
mvneta_eth_dev_create(struct rte_vdev_device * vdev,const char * name)796 mvneta_eth_dev_create(struct rte_vdev_device *vdev, const char *name)
797 {
798 int ret, fd = socket(AF_INET, SOCK_DGRAM, 0);
799 struct rte_eth_dev *eth_dev;
800 struct mvneta_priv *priv;
801 struct ifreq req;
802
803 eth_dev = rte_eth_dev_allocate(name);
804 if (!eth_dev)
805 return -ENOMEM;
806
807 priv = rte_zmalloc_socket(name, sizeof(*priv), 0, rte_socket_id());
808 if (!priv) {
809 ret = -ENOMEM;
810 goto out_free;
811 }
812 eth_dev->data->dev_private = priv;
813
814 eth_dev->data->mac_addrs =
815 rte_zmalloc("mac_addrs",
816 RTE_ETHER_ADDR_LEN * MVNETA_MAC_ADDRS_MAX, 0);
817 if (!eth_dev->data->mac_addrs) {
818 MVNETA_LOG(ERR, "Failed to allocate space for eth addrs");
819 ret = -ENOMEM;
820 goto out_free;
821 }
822
823 memset(&req, 0, sizeof(req));
824 strcpy(req.ifr_name, name);
825 ret = ioctl(fd, SIOCGIFHWADDR, &req);
826 if (ret)
827 goto out_free;
828
829 memcpy(eth_dev->data->mac_addrs[0].addr_bytes,
830 req.ifr_addr.sa_data, RTE_ETHER_ADDR_LEN);
831
832 eth_dev->device = &vdev->device;
833 eth_dev->rx_pkt_burst = mvneta_rx_pkt_burst;
834 mvneta_set_tx_function(eth_dev);
835 eth_dev->dev_ops = &mvneta_ops;
836
837 rte_eth_dev_probing_finish(eth_dev);
838 return 0;
839 out_free:
840 rte_eth_dev_release_port(eth_dev);
841
842 return ret;
843 }
844
845 /**
846 * Cleanup previously created device representing Ethernet port.
847 *
848 * @param eth_dev
849 * Pointer to the corresponding rte_eth_dev structure.
850 */
851 static void
mvneta_eth_dev_destroy(struct rte_eth_dev * eth_dev)852 mvneta_eth_dev_destroy(struct rte_eth_dev *eth_dev)
853 {
854 rte_eth_dev_release_port(eth_dev);
855 }
856
857 /**
858 * Cleanup previously created device representing Ethernet port.
859 *
860 * @param name
861 * Pointer to the port name.
862 */
863 static void
mvneta_eth_dev_destroy_name(const char * name)864 mvneta_eth_dev_destroy_name(const char *name)
865 {
866 struct rte_eth_dev *eth_dev;
867
868 eth_dev = rte_eth_dev_allocated(name);
869 if (!eth_dev)
870 return;
871
872 mvneta_eth_dev_destroy(eth_dev);
873 }
874
875 /**
876 * DPDK callback to register the virtual device.
877 *
878 * @param vdev
879 * Pointer to the virtual device.
880 *
881 * @return
882 * 0 on success, negative error value otherwise.
883 */
884 static int
rte_pmd_mvneta_probe(struct rte_vdev_device * vdev)885 rte_pmd_mvneta_probe(struct rte_vdev_device *vdev)
886 {
887 struct rte_kvargs *kvlist;
888 struct mvneta_ifnames ifnames;
889 int ret = -EINVAL;
890 uint32_t i, ifnum;
891 const char *params;
892
893 params = rte_vdev_device_args(vdev);
894 if (!params)
895 return -EINVAL;
896
897 kvlist = rte_kvargs_parse(params, valid_args);
898 if (!kvlist)
899 return -EINVAL;
900
901 ifnum = rte_kvargs_count(kvlist, MVNETA_IFACE_NAME_ARG);
902 if (ifnum > RTE_DIM(ifnames.names))
903 goto out_free_kvlist;
904
905 ifnames.idx = 0;
906 rte_kvargs_process(kvlist, MVNETA_IFACE_NAME_ARG,
907 mvneta_ifnames_get, &ifnames);
908
909 /*
910 * The below system initialization should be done only once,
911 * on the first provided configuration file
912 */
913 if (mvneta_dev_num)
914 goto init_devices;
915
916 MVNETA_LOG(INFO, "Perform MUSDK initializations");
917
918 ret = rte_mvep_init(MVEP_MOD_T_NETA, kvlist);
919 if (ret)
920 goto out_free_kvlist;
921
922 ret = mvneta_neta_init();
923 if (ret) {
924 MVNETA_LOG(ERR, "Failed to init NETA!");
925 rte_mvep_deinit(MVEP_MOD_T_NETA);
926 goto out_free_kvlist;
927 }
928
929 init_devices:
930 for (i = 0; i < ifnum; i++) {
931 MVNETA_LOG(INFO, "Creating %s", ifnames.names[i]);
932 ret = mvneta_eth_dev_create(vdev, ifnames.names[i]);
933 if (ret)
934 goto out_cleanup;
935
936 mvneta_dev_num++;
937 }
938
939 rte_kvargs_free(kvlist);
940
941 return 0;
942 out_cleanup:
943 rte_pmd_mvneta_remove(vdev);
944
945 out_free_kvlist:
946 rte_kvargs_free(kvlist);
947
948 return ret;
949 }
950
951 /**
952 * DPDK callback to remove virtual device.
953 *
954 * @param vdev
955 * Pointer to the removed virtual device.
956 *
957 * @return
958 * 0 on success, negative error value otherwise.
959 */
960 static int
rte_pmd_mvneta_remove(struct rte_vdev_device * vdev)961 rte_pmd_mvneta_remove(struct rte_vdev_device *vdev)
962 {
963 uint16_t port_id;
964 int ret = 0;
965
966 RTE_ETH_FOREACH_DEV(port_id) {
967 if (rte_eth_devices[port_id].device != &vdev->device)
968 continue;
969 ret |= rte_eth_dev_close(port_id);
970 }
971
972 return ret == 0 ? 0 : -EIO;
973 }
974
975 static struct rte_vdev_driver pmd_mvneta_drv = {
976 .probe = rte_pmd_mvneta_probe,
977 .remove = rte_pmd_mvneta_remove,
978 };
979
980 RTE_PMD_REGISTER_VDEV(net_mvneta, pmd_mvneta_drv);
981 RTE_PMD_REGISTER_PARAM_STRING(net_mvneta, "iface=<ifc>");
982 RTE_LOG_REGISTER_DEFAULT(mvneta_logtype, NOTICE);
983