1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2015 - 2016 CESNET
18 #include <rte_ethdev_driver.h>
19 #include <rte_ethdev_pci.h>
20 #include <rte_malloc.h>
21 #include <rte_memcpy.h>
22 #include <rte_kvargs.h>
25 #include "rte_eth_szedata2.h"
26 #include "szedata2_logs.h"
28 #define RTE_ETH_SZEDATA2_MAX_RX_QUEUES 32
29 #define RTE_ETH_SZEDATA2_MAX_TX_QUEUES 32
30 #define RTE_ETH_SZEDATA2_TX_LOCK_SIZE (32 * 1024 * 1024)
33 * size of szedata2_packet header with alignment
35 #define RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED 8
37 #define RTE_SZEDATA2_DRIVER_NAME net_szedata2
39 #define SZEDATA2_DEV_PATH_FMT "/dev/szedataII%u"
41 struct pmd_internals {
42 struct rte_eth_dev *dev;
43 uint16_t max_rx_queues;
44 uint16_t max_tx_queues;
45 char sze_dev[PATH_MAX];
46 struct rte_mem_resource *pci_rsc;
49 struct szedata2_rx_queue {
50 struct pmd_internals *priv;
54 struct rte_mempool *mb_pool;
55 volatile uint64_t rx_pkts;
56 volatile uint64_t rx_bytes;
57 volatile uint64_t err_pkts;
60 struct szedata2_tx_queue {
61 struct pmd_internals *priv;
64 volatile uint64_t tx_pkts;
65 volatile uint64_t tx_bytes;
66 volatile uint64_t err_pkts;
69 int szedata2_logtype_init;
70 int szedata2_logtype_driver;
72 static struct ether_addr eth_addr = {
73 .addr_bytes = { 0x00, 0x11, 0x17, 0x00, 0x00, 0x00 }
77 eth_szedata2_rx(void *queue,
78 struct rte_mbuf **bufs,
82 struct rte_mbuf *mbuf;
83 struct szedata2_rx_queue *sze_q = queue;
84 struct rte_pktmbuf_pool_private *mbp_priv;
90 uint64_t num_bytes = 0;
91 struct szedata *sze = sze_q->sze;
92 uint8_t *header_ptr = NULL; /* header of packet */
93 uint8_t *packet_ptr1 = NULL;
94 uint8_t *packet_ptr2 = NULL;
95 uint16_t packet_len1 = 0;
96 uint16_t packet_len2 = 0;
97 uint16_t hw_data_align;
99 if (unlikely(sze_q->sze == NULL || nb_pkts == 0))
103 * Reads the given number of packets from szedata2 channel given
104 * by queue and copies the packet data into a newly allocated mbuf
107 for (i = 0; i < nb_pkts; i++) {
108 mbuf = rte_pktmbuf_alloc(sze_q->mb_pool);
110 if (unlikely(mbuf == NULL)) {
111 sze_q->priv->dev->data->rx_mbuf_alloc_failed++;
115 /* get the next sze packet */
116 if (sze->ct_rx_lck != NULL && !sze->ct_rx_rem_bytes &&
117 sze->ct_rx_lck->next == NULL) {
118 /* unlock old data */
119 szedata_rx_unlock_data(sze_q->sze, sze->ct_rx_lck_orig);
120 sze->ct_rx_lck_orig = NULL;
121 sze->ct_rx_lck = NULL;
124 if (!sze->ct_rx_rem_bytes && sze->ct_rx_lck_orig == NULL) {
125 /* nothing to read, lock new data */
126 sze->ct_rx_lck = szedata_rx_lock_data(sze_q->sze, ~0U);
127 sze->ct_rx_lck_orig = sze->ct_rx_lck;
129 if (sze->ct_rx_lck == NULL) {
130 /* nothing to lock */
131 rte_pktmbuf_free(mbuf);
135 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
136 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len;
138 if (!sze->ct_rx_rem_bytes) {
139 rte_pktmbuf_free(mbuf);
144 if (sze->ct_rx_rem_bytes < RTE_SZE2_PACKET_HEADER_SIZE) {
147 * copy parts of header to merge buffer
149 if (sze->ct_rx_lck->next == NULL) {
150 rte_pktmbuf_free(mbuf);
154 /* copy first part of header */
155 rte_memcpy(sze->ct_rx_buffer, sze->ct_rx_cur_ptr,
156 sze->ct_rx_rem_bytes);
158 /* copy second part of header */
159 sze->ct_rx_lck = sze->ct_rx_lck->next;
160 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
161 rte_memcpy(sze->ct_rx_buffer + sze->ct_rx_rem_bytes,
163 RTE_SZE2_PACKET_HEADER_SIZE -
164 sze->ct_rx_rem_bytes);
166 sze->ct_rx_cur_ptr += RTE_SZE2_PACKET_HEADER_SIZE -
167 sze->ct_rx_rem_bytes;
168 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
169 RTE_SZE2_PACKET_HEADER_SIZE +
170 sze->ct_rx_rem_bytes;
172 header_ptr = (uint8_t *)sze->ct_rx_buffer;
175 header_ptr = (uint8_t *)sze->ct_rx_cur_ptr;
176 sze->ct_rx_cur_ptr += RTE_SZE2_PACKET_HEADER_SIZE;
177 sze->ct_rx_rem_bytes -= RTE_SZE2_PACKET_HEADER_SIZE;
180 sg_size = le16toh(*((uint16_t *)header_ptr));
181 hw_size = le16toh(*(((uint16_t *)header_ptr) + 1));
182 packet_size = sg_size -
183 RTE_SZE2_ALIGN8(RTE_SZE2_PACKET_HEADER_SIZE + hw_size);
186 /* checks if packet all right */
188 errx(5, "Zero segsize");
190 /* check sg_size and hwsize */
191 if (hw_size > sg_size - RTE_SZE2_PACKET_HEADER_SIZE) {
192 errx(10, "Hwsize bigger than expected. Segsize: %d, "
193 "hwsize: %d", sg_size, hw_size);
197 RTE_SZE2_ALIGN8(RTE_SZE2_PACKET_HEADER_SIZE + hw_size) -
198 RTE_SZE2_PACKET_HEADER_SIZE;
200 if (sze->ct_rx_rem_bytes >=
202 RTE_SZE2_PACKET_HEADER_SIZE)) {
204 /* one packet ready - go to another */
205 packet_ptr1 = sze->ct_rx_cur_ptr + hw_data_align;
206 packet_len1 = packet_size;
210 sze->ct_rx_cur_ptr += RTE_SZE2_ALIGN8(sg_size) -
211 RTE_SZE2_PACKET_HEADER_SIZE;
212 sze->ct_rx_rem_bytes -= RTE_SZE2_ALIGN8(sg_size) -
213 RTE_SZE2_PACKET_HEADER_SIZE;
216 if (sze->ct_rx_lck->next == NULL) {
217 errx(6, "Need \"next\" lock, "
218 "but it is missing: %u",
219 sze->ct_rx_rem_bytes);
223 if (sze->ct_rx_rem_bytes <= hw_data_align) {
224 uint16_t rem_size = hw_data_align -
225 sze->ct_rx_rem_bytes;
227 /* MOVE to next lock */
228 sze->ct_rx_lck = sze->ct_rx_lck->next;
230 (void *)(((uint8_t *)
231 (sze->ct_rx_lck->start)) + rem_size);
233 packet_ptr1 = sze->ct_rx_cur_ptr;
234 packet_len1 = packet_size;
238 sze->ct_rx_cur_ptr +=
239 RTE_SZE2_ALIGN8(packet_size);
240 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
241 rem_size - RTE_SZE2_ALIGN8(packet_size);
243 /* get pointer and length from first part */
244 packet_ptr1 = sze->ct_rx_cur_ptr +
246 packet_len1 = sze->ct_rx_rem_bytes -
249 /* MOVE to next lock */
250 sze->ct_rx_lck = sze->ct_rx_lck->next;
251 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
253 /* get pointer and length from second part */
254 packet_ptr2 = sze->ct_rx_cur_ptr;
255 packet_len2 = packet_size - packet_len1;
257 sze->ct_rx_cur_ptr +=
258 RTE_SZE2_ALIGN8(packet_size) -
260 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
261 (RTE_SZE2_ALIGN8(packet_size) -
266 if (unlikely(packet_ptr1 == NULL)) {
267 rte_pktmbuf_free(mbuf);
271 /* get the space available for data in the mbuf */
272 mbp_priv = rte_mempool_get_priv(sze_q->mb_pool);
273 buf_size = (uint16_t)(mbp_priv->mbuf_data_room_size -
274 RTE_PKTMBUF_HEADROOM);
276 if (packet_size <= buf_size) {
277 /* sze packet will fit in one mbuf, go ahead and copy */
278 rte_memcpy(rte_pktmbuf_mtod(mbuf, void *),
279 packet_ptr1, packet_len1);
280 if (packet_ptr2 != NULL) {
281 rte_memcpy((void *)(rte_pktmbuf_mtod(mbuf,
282 uint8_t *) + packet_len1),
283 packet_ptr2, packet_len2);
285 mbuf->data_len = (uint16_t)packet_size;
287 mbuf->pkt_len = packet_size;
288 mbuf->port = sze_q->in_port;
291 num_bytes += packet_size;
294 * sze packet will not fit in one mbuf,
295 * scattered mode is not enabled, drop packet
298 "SZE segment %d bytes will not fit in one mbuf "
299 "(%d bytes), scattered mode is not enabled, "
301 packet_size, buf_size);
302 rte_pktmbuf_free(mbuf);
306 sze_q->rx_pkts += num_rx;
307 sze_q->rx_bytes += num_bytes;
312 eth_szedata2_rx_scattered(void *queue,
313 struct rte_mbuf **bufs,
317 struct rte_mbuf *mbuf;
318 struct szedata2_rx_queue *sze_q = queue;
319 struct rte_pktmbuf_pool_private *mbp_priv;
324 uint16_t packet_size;
325 uint64_t num_bytes = 0;
326 struct szedata *sze = sze_q->sze;
327 uint8_t *header_ptr = NULL; /* header of packet */
328 uint8_t *packet_ptr1 = NULL;
329 uint8_t *packet_ptr2 = NULL;
330 uint16_t packet_len1 = 0;
331 uint16_t packet_len2 = 0;
332 uint16_t hw_data_align;
333 uint64_t *mbuf_failed_ptr =
334 &sze_q->priv->dev->data->rx_mbuf_alloc_failed;
336 if (unlikely(sze_q->sze == NULL || nb_pkts == 0))
340 * Reads the given number of packets from szedata2 channel given
341 * by queue and copies the packet data into a newly allocated mbuf
344 for (i = 0; i < nb_pkts; i++) {
345 const struct szedata_lock *ct_rx_lck_backup;
346 unsigned int ct_rx_rem_bytes_backup;
347 unsigned char *ct_rx_cur_ptr_backup;
349 /* get the next sze packet */
350 if (sze->ct_rx_lck != NULL && !sze->ct_rx_rem_bytes &&
351 sze->ct_rx_lck->next == NULL) {
352 /* unlock old data */
353 szedata_rx_unlock_data(sze_q->sze, sze->ct_rx_lck_orig);
354 sze->ct_rx_lck_orig = NULL;
355 sze->ct_rx_lck = NULL;
359 * Store items from sze structure which can be changed
360 * before mbuf allocating. Use these items in case of mbuf
361 * allocating failure.
363 ct_rx_lck_backup = sze->ct_rx_lck;
364 ct_rx_rem_bytes_backup = sze->ct_rx_rem_bytes;
365 ct_rx_cur_ptr_backup = sze->ct_rx_cur_ptr;
367 if (!sze->ct_rx_rem_bytes && sze->ct_rx_lck_orig == NULL) {
368 /* nothing to read, lock new data */
369 sze->ct_rx_lck = szedata_rx_lock_data(sze_q->sze, ~0U);
370 sze->ct_rx_lck_orig = sze->ct_rx_lck;
373 * Backup items from sze structure must be updated
374 * after locking to contain pointers to new locks.
376 ct_rx_lck_backup = sze->ct_rx_lck;
377 ct_rx_rem_bytes_backup = sze->ct_rx_rem_bytes;
378 ct_rx_cur_ptr_backup = sze->ct_rx_cur_ptr;
380 if (sze->ct_rx_lck == NULL)
381 /* nothing to lock */
384 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
385 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len;
387 if (!sze->ct_rx_rem_bytes)
391 if (sze->ct_rx_rem_bytes < RTE_SZE2_PACKET_HEADER_SIZE) {
393 * cut in header - copy parts of header to merge buffer
395 if (sze->ct_rx_lck->next == NULL)
398 /* copy first part of header */
399 rte_memcpy(sze->ct_rx_buffer, sze->ct_rx_cur_ptr,
400 sze->ct_rx_rem_bytes);
402 /* copy second part of header */
403 sze->ct_rx_lck = sze->ct_rx_lck->next;
404 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
405 rte_memcpy(sze->ct_rx_buffer + sze->ct_rx_rem_bytes,
407 RTE_SZE2_PACKET_HEADER_SIZE -
408 sze->ct_rx_rem_bytes);
410 sze->ct_rx_cur_ptr += RTE_SZE2_PACKET_HEADER_SIZE -
411 sze->ct_rx_rem_bytes;
412 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
413 RTE_SZE2_PACKET_HEADER_SIZE +
414 sze->ct_rx_rem_bytes;
416 header_ptr = (uint8_t *)sze->ct_rx_buffer;
419 header_ptr = (uint8_t *)sze->ct_rx_cur_ptr;
420 sze->ct_rx_cur_ptr += RTE_SZE2_PACKET_HEADER_SIZE;
421 sze->ct_rx_rem_bytes -= RTE_SZE2_PACKET_HEADER_SIZE;
424 sg_size = le16toh(*((uint16_t *)header_ptr));
425 hw_size = le16toh(*(((uint16_t *)header_ptr) + 1));
426 packet_size = sg_size -
427 RTE_SZE2_ALIGN8(RTE_SZE2_PACKET_HEADER_SIZE + hw_size);
430 /* checks if packet all right */
432 errx(5, "Zero segsize");
434 /* check sg_size and hwsize */
435 if (hw_size > sg_size - RTE_SZE2_PACKET_HEADER_SIZE) {
436 errx(10, "Hwsize bigger than expected. Segsize: %d, "
437 "hwsize: %d", sg_size, hw_size);
441 RTE_SZE2_ALIGN8((RTE_SZE2_PACKET_HEADER_SIZE +
442 hw_size)) - RTE_SZE2_PACKET_HEADER_SIZE;
444 if (sze->ct_rx_rem_bytes >=
446 RTE_SZE2_PACKET_HEADER_SIZE)) {
448 /* one packet ready - go to another */
449 packet_ptr1 = sze->ct_rx_cur_ptr + hw_data_align;
450 packet_len1 = packet_size;
454 sze->ct_rx_cur_ptr += RTE_SZE2_ALIGN8(sg_size) -
455 RTE_SZE2_PACKET_HEADER_SIZE;
456 sze->ct_rx_rem_bytes -= RTE_SZE2_ALIGN8(sg_size) -
457 RTE_SZE2_PACKET_HEADER_SIZE;
460 if (sze->ct_rx_lck->next == NULL) {
461 errx(6, "Need \"next\" lock, but it is "
462 "missing: %u", sze->ct_rx_rem_bytes);
466 if (sze->ct_rx_rem_bytes <= hw_data_align) {
467 uint16_t rem_size = hw_data_align -
468 sze->ct_rx_rem_bytes;
470 /* MOVE to next lock */
471 sze->ct_rx_lck = sze->ct_rx_lck->next;
473 (void *)(((uint8_t *)
474 (sze->ct_rx_lck->start)) + rem_size);
476 packet_ptr1 = sze->ct_rx_cur_ptr;
477 packet_len1 = packet_size;
481 sze->ct_rx_cur_ptr +=
482 RTE_SZE2_ALIGN8(packet_size);
483 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
484 rem_size - RTE_SZE2_ALIGN8(packet_size);
486 /* get pointer and length from first part */
487 packet_ptr1 = sze->ct_rx_cur_ptr +
489 packet_len1 = sze->ct_rx_rem_bytes -
492 /* MOVE to next lock */
493 sze->ct_rx_lck = sze->ct_rx_lck->next;
494 sze->ct_rx_cur_ptr = sze->ct_rx_lck->start;
496 /* get pointer and length from second part */
497 packet_ptr2 = sze->ct_rx_cur_ptr;
498 packet_len2 = packet_size - packet_len1;
500 sze->ct_rx_cur_ptr +=
501 RTE_SZE2_ALIGN8(packet_size) -
503 sze->ct_rx_rem_bytes = sze->ct_rx_lck->len -
504 (RTE_SZE2_ALIGN8(packet_size) -
509 if (unlikely(packet_ptr1 == NULL))
512 mbuf = rte_pktmbuf_alloc(sze_q->mb_pool);
514 if (unlikely(mbuf == NULL)) {
516 * Restore items from sze structure to state after
517 * unlocking (eventually locking).
519 sze->ct_rx_lck = ct_rx_lck_backup;
520 sze->ct_rx_rem_bytes = ct_rx_rem_bytes_backup;
521 sze->ct_rx_cur_ptr = ct_rx_cur_ptr_backup;
522 sze_q->priv->dev->data->rx_mbuf_alloc_failed++;
526 /* get the space available for data in the mbuf */
527 mbp_priv = rte_mempool_get_priv(sze_q->mb_pool);
528 buf_size = (uint16_t)(mbp_priv->mbuf_data_room_size -
529 RTE_PKTMBUF_HEADROOM);
531 if (packet_size <= buf_size) {
532 /* sze packet will fit in one mbuf, go ahead and copy */
533 rte_memcpy(rte_pktmbuf_mtod(mbuf, void *),
534 packet_ptr1, packet_len1);
535 if (packet_ptr2 != NULL) {
537 (rte_pktmbuf_mtod(mbuf, uint8_t *) +
538 packet_len1), packet_ptr2, packet_len2);
540 mbuf->data_len = (uint16_t)packet_size;
543 * sze packet will not fit in one mbuf,
544 * scatter packet into more mbufs
546 struct rte_mbuf *m = mbuf;
547 uint16_t len = rte_pktmbuf_tailroom(mbuf);
549 /* copy first part of packet */
550 /* fill first mbuf */
551 rte_memcpy(rte_pktmbuf_append(mbuf, len), packet_ptr1,
554 packet_ptr1 = ((uint8_t *)packet_ptr1) + len;
556 while (packet_len1 > 0) {
558 m->next = rte_pktmbuf_alloc(sze_q->mb_pool);
560 if (unlikely(m->next == NULL)) {
561 rte_pktmbuf_free(mbuf);
563 * Restore items from sze structure
564 * to state after unlocking (eventually
567 sze->ct_rx_lck = ct_rx_lck_backup;
568 sze->ct_rx_rem_bytes =
569 ct_rx_rem_bytes_backup;
571 ct_rx_cur_ptr_backup;
572 (*mbuf_failed_ptr)++;
578 len = RTE_MIN(rte_pktmbuf_tailroom(m),
580 rte_memcpy(rte_pktmbuf_append(mbuf, len),
585 packet_ptr1 = ((uint8_t *)packet_ptr1) + len;
588 if (packet_ptr2 != NULL) {
589 /* copy second part of packet, if exists */
590 /* fill the rest of currently last mbuf */
591 len = rte_pktmbuf_tailroom(m);
592 rte_memcpy(rte_pktmbuf_append(mbuf, len),
595 packet_ptr2 = ((uint8_t *)packet_ptr2) + len;
597 while (packet_len2 > 0) {
599 m->next = rte_pktmbuf_alloc(
602 if (unlikely(m->next == NULL)) {
603 rte_pktmbuf_free(mbuf);
605 * Restore items from sze
606 * structure to state after
607 * unlocking (eventually
612 sze->ct_rx_rem_bytes =
613 ct_rx_rem_bytes_backup;
615 ct_rx_cur_ptr_backup;
616 (*mbuf_failed_ptr)++;
622 len = RTE_MIN(rte_pktmbuf_tailroom(m),
625 rte_pktmbuf_append(mbuf, len),
630 packet_ptr2 = ((uint8_t *)packet_ptr2) +
635 mbuf->pkt_len = packet_size;
636 mbuf->port = sze_q->in_port;
639 num_bytes += packet_size;
643 sze_q->rx_pkts += num_rx;
644 sze_q->rx_bytes += num_bytes;
649 eth_szedata2_tx(void *queue,
650 struct rte_mbuf **bufs,
653 struct rte_mbuf *mbuf;
654 struct szedata2_tx_queue *sze_q = queue;
656 uint64_t num_bytes = 0;
658 const struct szedata_lock *lck;
664 uint32_t unlock_size;
667 uint16_t pkt_left = nb_pkts;
669 if (sze_q->sze == NULL || nb_pkts == 0)
672 while (pkt_left > 0) {
674 lck = szedata_tx_lock_data(sze_q->sze,
675 RTE_ETH_SZEDATA2_TX_LOCK_SIZE,
681 lock_size = lck->len;
682 lock_size2 = lck->next ? lck->next->len : 0;
685 mbuf = bufs[nb_pkts - pkt_left];
687 pkt_len = mbuf->pkt_len;
688 mbuf_segs = mbuf->nb_segs;
690 hwpkt_len = RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED +
691 RTE_SZE2_ALIGN8(pkt_len);
693 if (lock_size + lock_size2 < hwpkt_len) {
694 szedata_tx_unlock_data(sze_q->sze, lck, unlock_size);
698 num_bytes += pkt_len;
700 if (lock_size > hwpkt_len) {
705 /* write packet length at first 2 bytes in 8B header */
706 *((uint16_t *)dst) = htole16(
707 RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED +
709 *(((uint16_t *)dst) + 1) = htole16(0);
711 /* copy packet from mbuf */
712 tmp_dst = ((uint8_t *)(dst)) +
713 RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED;
714 if (mbuf_segs == 1) {
716 * non-scattered packet,
717 * transmit from one mbuf
720 rte_pktmbuf_mtod(mbuf, const void *),
723 /* scattered packet, transmit from more mbufs */
724 struct rte_mbuf *m = mbuf;
730 tmp_dst = ((uint8_t *)(tmp_dst)) +
737 dst = ((uint8_t *)dst) + hwpkt_len;
738 unlock_size += hwpkt_len;
739 lock_size -= hwpkt_len;
741 rte_pktmbuf_free(mbuf);
745 szedata_tx_unlock_data(sze_q->sze, lck,
750 } else if (lock_size + lock_size2 >= hwpkt_len) {
754 /* write packet length at first 2 bytes in 8B header */
756 htole16(RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED +
758 *(((uint16_t *)dst) + 1) = htole16(0);
761 * If the raw packet (pkt_len) is smaller than lock_size
762 * get the correct length for memcpy
765 pkt_len < lock_size -
766 RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED ?
768 lock_size - RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED;
770 rem_len = hwpkt_len - lock_size;
772 tmp_dst = ((uint8_t *)(dst)) +
773 RTE_SZE2_PACKET_HEADER_SIZE_ALIGNED;
774 if (mbuf_segs == 1) {
776 * non-scattered packet,
777 * transmit from one mbuf
779 /* copy part of packet to first area */
781 rte_pktmbuf_mtod(mbuf, const void *),
785 dst = lck->next->start;
787 /* copy part of packet to second area */
789 (const void *)(rte_pktmbuf_mtod(mbuf,
791 write_len), pkt_len - write_len);
793 /* scattered packet, transmit from more mbufs */
794 struct rte_mbuf *m = mbuf;
795 uint16_t written = 0;
796 uint16_t to_write = 0;
797 bool new_mbuf = true;
798 uint16_t write_off = 0;
800 /* copy part of packet to first area */
801 while (m && written < write_len) {
802 to_write = RTE_MIN(m->data_len,
803 write_len - written);
809 tmp_dst = ((uint8_t *)(tmp_dst)) +
811 if (m->data_len <= write_len -
822 dst = lck->next->start;
826 write_off = new_mbuf ? 0 : to_write;
828 /* copy part of packet to second area */
829 while (m && written < pkt_len - write_len) {
830 rte_memcpy(tmp_dst, (const void *)
832 uint8_t *) + write_off),
833 m->data_len - write_off);
835 tmp_dst = ((uint8_t *)(tmp_dst)) +
836 (m->data_len - write_off);
837 written += m->data_len - write_off;
843 dst = ((uint8_t *)dst) + rem_len;
844 unlock_size += hwpkt_len;
845 lock_size = lock_size2 - rem_len;
848 rte_pktmbuf_free(mbuf);
852 szedata_tx_unlock_data(sze_q->sze, lck, unlock_size);
856 sze_q->tx_pkts += num_tx;
857 sze_q->err_pkts += nb_pkts - num_tx;
858 sze_q->tx_bytes += num_bytes;
863 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rxq_id)
865 struct szedata2_rx_queue *rxq = dev->data->rx_queues[rxq_id];
867 struct pmd_internals *internals = (struct pmd_internals *)
868 dev->data->dev_private;
870 if (rxq->sze == NULL) {
871 uint32_t rx = 1 << rxq->rx_channel;
873 rxq->sze = szedata_open(internals->sze_dev);
874 if (rxq->sze == NULL)
876 ret = szedata_subscribe3(rxq->sze, &rx, &tx);
877 if (ret != 0 || rx == 0)
881 ret = szedata_start(rxq->sze);
884 dev->data->rx_queue_state[rxq_id] = RTE_ETH_QUEUE_STATE_STARTED;
888 szedata_close(rxq->sze);
894 eth_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rxq_id)
896 struct szedata2_rx_queue *rxq = dev->data->rx_queues[rxq_id];
898 if (rxq->sze != NULL) {
899 szedata_close(rxq->sze);
903 dev->data->rx_queue_state[rxq_id] = RTE_ETH_QUEUE_STATE_STOPPED;
908 eth_tx_queue_start(struct rte_eth_dev *dev, uint16_t txq_id)
910 struct szedata2_tx_queue *txq = dev->data->tx_queues[txq_id];
912 struct pmd_internals *internals = (struct pmd_internals *)
913 dev->data->dev_private;
915 if (txq->sze == NULL) {
917 uint32_t tx = 1 << txq->tx_channel;
918 txq->sze = szedata_open(internals->sze_dev);
919 if (txq->sze == NULL)
921 ret = szedata_subscribe3(txq->sze, &rx, &tx);
922 if (ret != 0 || tx == 0)
926 ret = szedata_start(txq->sze);
929 dev->data->tx_queue_state[txq_id] = RTE_ETH_QUEUE_STATE_STARTED;
933 szedata_close(txq->sze);
939 eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t txq_id)
941 struct szedata2_tx_queue *txq = dev->data->tx_queues[txq_id];
943 if (txq->sze != NULL) {
944 szedata_close(txq->sze);
948 dev->data->tx_queue_state[txq_id] = RTE_ETH_QUEUE_STATE_STOPPED;
953 eth_dev_start(struct rte_eth_dev *dev)
957 uint16_t nb_rx = dev->data->nb_rx_queues;
958 uint16_t nb_tx = dev->data->nb_tx_queues;
960 for (i = 0; i < nb_rx; i++) {
961 ret = eth_rx_queue_start(dev, i);
966 for (i = 0; i < nb_tx; i++) {
967 ret = eth_tx_queue_start(dev, i);
975 for (i = 0; i < nb_tx; i++)
976 eth_tx_queue_stop(dev, i);
978 for (i = 0; i < nb_rx; i++)
979 eth_rx_queue_stop(dev, i);
984 eth_dev_stop(struct rte_eth_dev *dev)
987 uint16_t nb_rx = dev->data->nb_rx_queues;
988 uint16_t nb_tx = dev->data->nb_tx_queues;
990 for (i = 0; i < nb_tx; i++)
991 eth_tx_queue_stop(dev, i);
993 for (i = 0; i < nb_rx; i++)
994 eth_rx_queue_stop(dev, i);
998 eth_dev_configure(struct rte_eth_dev *dev)
1000 struct rte_eth_dev_data *data = dev->data;
1001 if (data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_SCATTER) {
1002 dev->rx_pkt_burst = eth_szedata2_rx_scattered;
1003 data->scattered_rx = 1;
1005 dev->rx_pkt_burst = eth_szedata2_rx;
1006 data->scattered_rx = 0;
1012 eth_dev_info(struct rte_eth_dev *dev,
1013 struct rte_eth_dev_info *dev_info)
1015 struct pmd_internals *internals = dev->data->dev_private;
1017 dev_info->if_index = 0;
1018 dev_info->max_mac_addrs = 1;
1019 dev_info->max_rx_pktlen = (uint32_t)-1;
1020 dev_info->max_rx_queues = internals->max_rx_queues;
1021 dev_info->max_tx_queues = internals->max_tx_queues;
1022 dev_info->min_rx_bufsize = 0;
1023 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_SCATTER;
1024 dev_info->tx_offload_capa = 0;
1025 dev_info->rx_queue_offload_capa = 0;
1026 dev_info->tx_queue_offload_capa = 0;
1027 dev_info->speed_capa = ETH_LINK_SPEED_100G;
1031 eth_stats_get(struct rte_eth_dev *dev,
1032 struct rte_eth_stats *stats)
1035 uint16_t nb_rx = dev->data->nb_rx_queues;
1036 uint16_t nb_tx = dev->data->nb_tx_queues;
1037 uint64_t rx_total = 0;
1038 uint64_t tx_total = 0;
1039 uint64_t tx_err_total = 0;
1040 uint64_t rx_total_bytes = 0;
1041 uint64_t tx_total_bytes = 0;
1043 for (i = 0; i < nb_rx; i++) {
1044 struct szedata2_rx_queue *rxq = dev->data->rx_queues[i];
1046 if (i < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
1047 stats->q_ipackets[i] = rxq->rx_pkts;
1048 stats->q_ibytes[i] = rxq->rx_bytes;
1050 rx_total += rxq->rx_pkts;
1051 rx_total_bytes += rxq->rx_bytes;
1054 for (i = 0; i < nb_tx; i++) {
1055 struct szedata2_tx_queue *txq = dev->data->tx_queues[i];
1057 if (i < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
1058 stats->q_opackets[i] = txq->tx_pkts;
1059 stats->q_obytes[i] = txq->tx_bytes;
1060 stats->q_errors[i] = txq->err_pkts;
1062 tx_total += txq->tx_pkts;
1063 tx_total_bytes += txq->tx_bytes;
1064 tx_err_total += txq->err_pkts;
1067 stats->ipackets = rx_total;
1068 stats->opackets = tx_total;
1069 stats->ibytes = rx_total_bytes;
1070 stats->obytes = tx_total_bytes;
1071 stats->oerrors = tx_err_total;
1072 stats->rx_nombuf = dev->data->rx_mbuf_alloc_failed;
1078 eth_stats_reset(struct rte_eth_dev *dev)
1081 uint16_t nb_rx = dev->data->nb_rx_queues;
1082 uint16_t nb_tx = dev->data->nb_tx_queues;
1084 for (i = 0; i < nb_rx; i++) {
1085 struct szedata2_rx_queue *rxq = dev->data->rx_queues[i];
1090 for (i = 0; i < nb_tx; i++) {
1091 struct szedata2_tx_queue *txq = dev->data->tx_queues[i];
1099 eth_rx_queue_release(void *q)
1101 struct szedata2_rx_queue *rxq = (struct szedata2_rx_queue *)q;
1104 if (rxq->sze != NULL)
1105 szedata_close(rxq->sze);
1111 eth_tx_queue_release(void *q)
1113 struct szedata2_tx_queue *txq = (struct szedata2_tx_queue *)q;
1116 if (txq->sze != NULL)
1117 szedata_close(txq->sze);
1123 eth_dev_close(struct rte_eth_dev *dev)
1126 uint16_t nb_rx = dev->data->nb_rx_queues;
1127 uint16_t nb_tx = dev->data->nb_tx_queues;
1131 for (i = 0; i < nb_rx; i++) {
1132 eth_rx_queue_release(dev->data->rx_queues[i]);
1133 dev->data->rx_queues[i] = NULL;
1135 dev->data->nb_rx_queues = 0;
1136 for (i = 0; i < nb_tx; i++) {
1137 eth_tx_queue_release(dev->data->tx_queues[i]);
1138 dev->data->tx_queues[i] = NULL;
1140 dev->data->nb_tx_queues = 0;
1144 eth_link_update(struct rte_eth_dev *dev,
1145 int wait_to_complete __rte_unused)
1147 struct rte_eth_link link;
1149 memset(&link, 0, sizeof(link));
1151 link.link_speed = ETH_SPEED_NUM_100G;
1152 link.link_duplex = ETH_LINK_FULL_DUPLEX;
1153 link.link_status = ETH_LINK_UP;
1154 link.link_autoneg = ETH_LINK_FIXED;
1156 rte_eth_linkstatus_set(dev, &link);
1161 eth_dev_set_link_up(struct rte_eth_dev *dev __rte_unused)
1163 PMD_DRV_LOG(WARNING, "Setting link up is not supported.");
1168 eth_dev_set_link_down(struct rte_eth_dev *dev __rte_unused)
1170 PMD_DRV_LOG(WARNING, "Setting link down is not supported.");
1175 eth_rx_queue_setup(struct rte_eth_dev *dev,
1176 uint16_t rx_queue_id,
1177 uint16_t nb_rx_desc __rte_unused,
1178 unsigned int socket_id,
1179 const struct rte_eth_rxconf *rx_conf __rte_unused,
1180 struct rte_mempool *mb_pool)
1182 struct pmd_internals *internals = dev->data->dev_private;
1183 struct szedata2_rx_queue *rxq;
1185 uint32_t rx = 1 << rx_queue_id;
1188 if (dev->data->rx_queues[rx_queue_id] != NULL) {
1189 eth_rx_queue_release(dev->data->rx_queues[rx_queue_id]);
1190 dev->data->rx_queues[rx_queue_id] = NULL;
1193 rxq = rte_zmalloc_socket("szedata2 rx queue",
1194 sizeof(struct szedata2_rx_queue),
1195 RTE_CACHE_LINE_SIZE, socket_id);
1197 PMD_INIT_LOG(ERR, "rte_zmalloc_socket() failed for rx queue id "
1198 "%" PRIu16 "!", rx_queue_id);
1202 rxq->priv = internals;
1203 rxq->sze = szedata_open(internals->sze_dev);
1204 if (rxq->sze == NULL) {
1205 PMD_INIT_LOG(ERR, "szedata_open() failed for rx queue id "
1206 "%" PRIu16 "!", rx_queue_id);
1207 eth_rx_queue_release(rxq);
1210 ret = szedata_subscribe3(rxq->sze, &rx, &tx);
1211 if (ret != 0 || rx == 0) {
1212 PMD_INIT_LOG(ERR, "szedata_subscribe3() failed for rx queue id "
1213 "%" PRIu16 "!", rx_queue_id);
1214 eth_rx_queue_release(rxq);
1217 rxq->rx_channel = rx_queue_id;
1218 rxq->in_port = dev->data->port_id;
1219 rxq->mb_pool = mb_pool;
1224 dev->data->rx_queues[rx_queue_id] = rxq;
1226 PMD_INIT_LOG(DEBUG, "Configured rx queue id %" PRIu16 " on socket "
1227 "%u.", rx_queue_id, socket_id);
1233 eth_tx_queue_setup(struct rte_eth_dev *dev,
1234 uint16_t tx_queue_id,
1235 uint16_t nb_tx_desc __rte_unused,
1236 unsigned int socket_id,
1237 const struct rte_eth_txconf *tx_conf __rte_unused)
1239 struct pmd_internals *internals = dev->data->dev_private;
1240 struct szedata2_tx_queue *txq;
1243 uint32_t tx = 1 << tx_queue_id;
1245 if (dev->data->tx_queues[tx_queue_id] != NULL) {
1246 eth_tx_queue_release(dev->data->tx_queues[tx_queue_id]);
1247 dev->data->tx_queues[tx_queue_id] = NULL;
1250 txq = rte_zmalloc_socket("szedata2 tx queue",
1251 sizeof(struct szedata2_tx_queue),
1252 RTE_CACHE_LINE_SIZE, socket_id);
1254 PMD_INIT_LOG(ERR, "rte_zmalloc_socket() failed for tx queue id "
1255 "%" PRIu16 "!", tx_queue_id);
1259 txq->priv = internals;
1260 txq->sze = szedata_open(internals->sze_dev);
1261 if (txq->sze == NULL) {
1262 PMD_INIT_LOG(ERR, "szedata_open() failed for tx queue id "
1263 "%" PRIu16 "!", tx_queue_id);
1264 eth_tx_queue_release(txq);
1267 ret = szedata_subscribe3(txq->sze, &rx, &tx);
1268 if (ret != 0 || tx == 0) {
1269 PMD_INIT_LOG(ERR, "szedata_subscribe3() failed for tx queue id "
1270 "%" PRIu16 "!", tx_queue_id);
1271 eth_tx_queue_release(txq);
1274 txq->tx_channel = tx_queue_id;
1279 dev->data->tx_queues[tx_queue_id] = txq;
1281 PMD_INIT_LOG(DEBUG, "Configured tx queue id %" PRIu16 " on socket "
1282 "%u.", tx_queue_id, socket_id);
1288 eth_mac_addr_set(struct rte_eth_dev *dev __rte_unused,
1289 struct ether_addr *mac_addr __rte_unused)
1295 eth_promiscuous_enable(struct rte_eth_dev *dev __rte_unused)
1297 PMD_DRV_LOG(WARNING, "Enabling promiscuous mode is not supported. "
1298 "The card is always in promiscuous mode.");
1302 eth_promiscuous_disable(struct rte_eth_dev *dev __rte_unused)
1304 PMD_DRV_LOG(WARNING, "Disabling promiscuous mode is not supported. "
1305 "The card is always in promiscuous mode.");
1309 eth_allmulticast_enable(struct rte_eth_dev *dev __rte_unused)
1311 PMD_DRV_LOG(WARNING, "Enabling allmulticast mode is not supported.");
1315 eth_allmulticast_disable(struct rte_eth_dev *dev __rte_unused)
1317 PMD_DRV_LOG(WARNING, "Disabling allmulticast mode is not supported.");
1320 static const struct eth_dev_ops ops = {
1321 .dev_start = eth_dev_start,
1322 .dev_stop = eth_dev_stop,
1323 .dev_set_link_up = eth_dev_set_link_up,
1324 .dev_set_link_down = eth_dev_set_link_down,
1325 .dev_close = eth_dev_close,
1326 .dev_configure = eth_dev_configure,
1327 .dev_infos_get = eth_dev_info,
1328 .promiscuous_enable = eth_promiscuous_enable,
1329 .promiscuous_disable = eth_promiscuous_disable,
1330 .allmulticast_enable = eth_allmulticast_enable,
1331 .allmulticast_disable = eth_allmulticast_disable,
1332 .rx_queue_start = eth_rx_queue_start,
1333 .rx_queue_stop = eth_rx_queue_stop,
1334 .tx_queue_start = eth_tx_queue_start,
1335 .tx_queue_stop = eth_tx_queue_stop,
1336 .rx_queue_setup = eth_rx_queue_setup,
1337 .tx_queue_setup = eth_tx_queue_setup,
1338 .rx_queue_release = eth_rx_queue_release,
1339 .tx_queue_release = eth_tx_queue_release,
1340 .link_update = eth_link_update,
1341 .stats_get = eth_stats_get,
1342 .stats_reset = eth_stats_reset,
1343 .mac_addr_set = eth_mac_addr_set,
1347 * This function goes through sysfs and looks for an index of szedata2
1348 * device file (/dev/szedataIIX, where X is the index).
1355 get_szedata2_index(const struct rte_pci_addr *pcislot_addr, uint32_t *index)
1358 struct dirent *entry;
1362 char pcislot_path[PATH_MAX];
1368 dir = opendir("/sys/class/combo");
1373 * Iterate through all combosixX directories.
1374 * When the value in /sys/class/combo/combosixX/device/pcislot
1375 * file is the location of the ethernet device dev, "X" is the
1376 * index of the device.
1378 while ((entry = readdir(dir)) != NULL) {
1379 ret = sscanf(entry->d_name, "combosix%u", &tmp_index);
1383 snprintf(pcislot_path, PATH_MAX,
1384 "/sys/class/combo/combosix%u/device/pcislot",
1387 fd = fopen(pcislot_path, "r");
1391 ret = fscanf(fd, "%8" SCNx32 ":%2" SCNx8 ":%2" SCNx8 ".%" SCNx8,
1392 &domain, &bus, &devid, &function);
1397 if (pcislot_addr->domain == domain &&
1398 pcislot_addr->bus == bus &&
1399 pcislot_addr->devid == devid &&
1400 pcislot_addr->function == function) {
1412 rte_szedata2_eth_dev_init(struct rte_eth_dev *dev)
1414 struct rte_eth_dev_data *data = dev->data;
1415 struct pmd_internals *internals = (struct pmd_internals *)
1417 struct szedata *szedata_temp;
1419 uint32_t szedata2_index;
1420 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1421 struct rte_pci_addr *pci_addr = &pci_dev->addr;
1422 struct rte_mem_resource *pci_rsc =
1423 &pci_dev->mem_resource[PCI_RESOURCE_NUMBER];
1424 char rsc_filename[PATH_MAX];
1425 void *pci_resource_ptr = NULL;
1428 PMD_INIT_LOG(INFO, "Initializing szedata2 device (" PCI_PRI_FMT ")",
1429 pci_addr->domain, pci_addr->bus, pci_addr->devid,
1430 pci_addr->function);
1432 internals->dev = dev;
1434 /* Get index of szedata2 device file and create path to device file */
1435 ret = get_szedata2_index(pci_addr, &szedata2_index);
1437 PMD_INIT_LOG(ERR, "Failed to get szedata2 device index!");
1440 snprintf(internals->sze_dev, PATH_MAX, SZEDATA2_DEV_PATH_FMT,
1443 PMD_INIT_LOG(INFO, "SZEDATA2 path: %s", internals->sze_dev);
1446 * Get number of available DMA RX and TX channels, which is maximum
1447 * number of queues that can be created and store it in private device
1450 szedata_temp = szedata_open(internals->sze_dev);
1451 if (szedata_temp == NULL) {
1452 PMD_INIT_LOG(ERR, "szedata_open(): failed to open %s",
1453 internals->sze_dev);
1456 internals->max_rx_queues = szedata_ifaces_available(szedata_temp,
1458 internals->max_tx_queues = szedata_ifaces_available(szedata_temp,
1460 szedata_close(szedata_temp);
1462 PMD_INIT_LOG(INFO, "Available DMA channels RX: %u TX: %u",
1463 internals->max_rx_queues, internals->max_tx_queues);
1465 /* Set rx, tx burst functions */
1466 if (data->scattered_rx == 1)
1467 dev->rx_pkt_burst = eth_szedata2_rx_scattered;
1469 dev->rx_pkt_burst = eth_szedata2_rx;
1470 dev->tx_pkt_burst = eth_szedata2_tx;
1472 /* Set function callbacks for Ethernet API */
1473 dev->dev_ops = &ops;
1475 rte_eth_copy_pci_info(dev, pci_dev);
1477 /* mmap pci resource0 file to rte_mem_resource structure */
1478 if (pci_dev->mem_resource[PCI_RESOURCE_NUMBER].phys_addr ==
1480 PMD_INIT_LOG(ERR, "Missing resource%u file",
1481 PCI_RESOURCE_NUMBER);
1484 snprintf(rsc_filename, PATH_MAX,
1485 "%s/" PCI_PRI_FMT "/resource%u", rte_pci_get_sysfs_path(),
1486 pci_addr->domain, pci_addr->bus,
1487 pci_addr->devid, pci_addr->function, PCI_RESOURCE_NUMBER);
1488 fd = open(rsc_filename, O_RDWR);
1490 PMD_INIT_LOG(ERR, "Could not open file %s", rsc_filename);
1494 pci_resource_ptr = mmap(0,
1495 pci_dev->mem_resource[PCI_RESOURCE_NUMBER].len,
1496 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1498 if (pci_resource_ptr == MAP_FAILED) {
1499 PMD_INIT_LOG(ERR, "Could not mmap file %s (fd = %d)",
1503 pci_dev->mem_resource[PCI_RESOURCE_NUMBER].addr = pci_resource_ptr;
1504 internals->pci_rsc = pci_rsc;
1506 PMD_INIT_LOG(DEBUG, "resource%u phys_addr = 0x%llx len = %llu "
1507 "virt addr = %llx", PCI_RESOURCE_NUMBER,
1508 (unsigned long long)pci_rsc->phys_addr,
1509 (unsigned long long)pci_rsc->len,
1510 (unsigned long long)pci_rsc->addr);
1512 /* Get link state */
1513 eth_link_update(dev, 0);
1515 /* Allocate space for one mac address */
1516 data->mac_addrs = rte_zmalloc(data->name, sizeof(struct ether_addr),
1517 RTE_CACHE_LINE_SIZE);
1518 if (data->mac_addrs == NULL) {
1519 PMD_INIT_LOG(ERR, "Could not alloc space for MAC address!");
1520 munmap(pci_dev->mem_resource[PCI_RESOURCE_NUMBER].addr,
1521 pci_dev->mem_resource[PCI_RESOURCE_NUMBER].len);
1525 ether_addr_copy(ð_addr, data->mac_addrs);
1527 PMD_INIT_LOG(INFO, "szedata2 device ("
1528 PCI_PRI_FMT ") successfully initialized",
1529 pci_addr->domain, pci_addr->bus, pci_addr->devid,
1530 pci_addr->function);
1536 rte_szedata2_eth_dev_uninit(struct rte_eth_dev *dev)
1538 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
1539 struct rte_pci_addr *pci_addr = &pci_dev->addr;
1541 rte_free(dev->data->mac_addrs);
1542 dev->data->mac_addrs = NULL;
1543 munmap(pci_dev->mem_resource[PCI_RESOURCE_NUMBER].addr,
1544 pci_dev->mem_resource[PCI_RESOURCE_NUMBER].len);
1546 PMD_DRV_LOG(INFO, "szedata2 device ("
1547 PCI_PRI_FMT ") successfully uninitialized",
1548 pci_addr->domain, pci_addr->bus, pci_addr->devid,
1549 pci_addr->function);
1554 static const struct rte_pci_id rte_szedata2_pci_id_table[] = {
1556 RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE,
1557 PCI_DEVICE_ID_NETCOPE_COMBO80G)
1560 RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE,
1561 PCI_DEVICE_ID_NETCOPE_COMBO100G)
1564 RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE,
1565 PCI_DEVICE_ID_NETCOPE_COMBO100G2)
1572 static int szedata2_eth_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
1573 struct rte_pci_device *pci_dev)
1575 return rte_eth_dev_pci_generic_probe(pci_dev,
1576 sizeof(struct pmd_internals), rte_szedata2_eth_dev_init);
1579 static int szedata2_eth_pci_remove(struct rte_pci_device *pci_dev)
1581 return rte_eth_dev_pci_generic_remove(pci_dev,
1582 rte_szedata2_eth_dev_uninit);
1585 static struct rte_pci_driver szedata2_eth_driver = {
1586 .id_table = rte_szedata2_pci_id_table,
1587 .probe = szedata2_eth_pci_probe,
1588 .remove = szedata2_eth_pci_remove,
1591 RTE_PMD_REGISTER_PCI(RTE_SZEDATA2_DRIVER_NAME, szedata2_eth_driver);
1592 RTE_PMD_REGISTER_PCI_TABLE(RTE_SZEDATA2_DRIVER_NAME, rte_szedata2_pci_id_table);
1593 RTE_PMD_REGISTER_KMOD_DEP(RTE_SZEDATA2_DRIVER_NAME,
1594 "* combo6core & combov3 & szedata2 & szedata2_cv3");
1596 RTE_INIT(szedata2_init_log);
1598 szedata2_init_log(void)
1600 szedata2_logtype_init = rte_log_register("pmd.net.szedata2.init");
1601 if (szedata2_logtype_init >= 0)
1602 rte_log_set_level(szedata2_logtype_init, RTE_LOG_NOTICE);
1603 szedata2_logtype_driver = rte_log_register("pmd.net.szedata2.driver");
1604 if (szedata2_logtype_driver >= 0)
1605 rte_log_set_level(szedata2_logtype_driver, RTE_LOG_NOTICE);