The driver use of memcpy is for control path work, for example, flow
configuration and so is fine using the standard libc memcpy function in
place of the DPDK-specific rte_memcpy version.

Signed-off-by: Bruce Richardson <[email protected]>
---
 drivers/net/intel/idpf/base/idpf_osdep.h      |  5 ++---
 drivers/net/intel/idpf/idpf_common_device.c   |  2 +-
 drivers/net/intel/idpf/idpf_common_virtchnl.c | 20 +++++++++----------
 drivers/net/intel/idpf/idpf_ethdev.c          | 10 +++++-----
 drivers/net/intel/idpf/idpf_rxtx.c            |  8 ++++----
 5 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/drivers/net/intel/idpf/base/idpf_osdep.h 
b/drivers/net/intel/idpf/base/idpf_osdep.h
index 47b95d0da6..67bc33f2e6 100644
--- a/drivers/net/intel/idpf/base/idpf_osdep.h
+++ b/drivers/net/intel/idpf/base/idpf_osdep.h
@@ -14,7 +14,6 @@
 #include <stdbool.h>
 
 #include <rte_common.h>
-#include <rte_memcpy.h>
 #include <rte_malloc.h>
 #include <rte_memzone.h>
 #include <rte_byteorder.h>
@@ -199,8 +198,8 @@ struct __rte_packed_begin idpf_virt_mem {
 #define idpf_free(h, m)                rte_free(m)
 
 #define idpf_memset(a, b, c, d)        memset((a), (b), (c))
-#define idpf_memcpy(a, b, c, d)        rte_memcpy((a), (b), (c))
-#define idpf_memdup(a, b, c, d)        rte_memcpy(idpf_malloc(a, c), b, c)
+#define idpf_memcpy(a, b, c, d)        memcpy((a), (b), (c))
+#define idpf_memdup(a, b, c, d)        memcpy(idpf_malloc(a, c), b, c)
 
 #define CPU_TO_BE16(o) rte_cpu_to_be_16(o)
 #define CPU_TO_BE32(o) rte_cpu_to_be_32(o)
diff --git a/drivers/net/intel/idpf/idpf_common_device.c 
b/drivers/net/intel/idpf/idpf_common_device.c
index 24ee00db23..f27a911977 100644
--- a/drivers/net/intel/idpf/idpf_common_device.c
+++ b/drivers/net/intel/idpf/idpf_common_device.c
@@ -496,7 +496,7 @@ idpf_vport_init(struct idpf_vport *vport,
        vport->num_rx_q = vport_info->num_rx_q;
        vport->num_rx_bufq = vport_info->num_rx_bufq;
        vport->max_mtu = vport_info->max_mtu;
-       rte_memcpy(vport->default_mac_addr,
+       memcpy(vport->default_mac_addr,
                   vport_info->default_mac_addr, ETH_ALEN);
        vport->rss_algorithm = vport_info->rss_algorithm;
        vport->rss_key_size = RTE_MIN(IDPF_RSS_KEY_LEN,
diff --git a/drivers/net/intel/idpf/idpf_common_virtchnl.c 
b/drivers/net/intel/idpf/idpf_common_virtchnl.c
index f8c487c537..4befd5fc83 100644
--- a/drivers/net/intel/idpf/idpf_common_virtchnl.c
+++ b/drivers/net/intel/idpf/idpf_common_virtchnl.c
@@ -141,7 +141,7 @@ idpf_read_msg_from_cp(struct idpf_adapter *adapter, 
uint16_t buf_len,
                return result;
        }
 
-       rte_memcpy(buf, ctlq_msg.ctx.indirect.payload->va, buf_len);
+       memcpy(buf, ctlq_msg.ctx.indirect.payload->va, buf_len);
 
        opcode = rte_le_to_cpu_32(ctlq_msg.cookie.mbx.chnl_opcode);
        adapter->cmd_retval = rte_le_to_cpu_32(ctlq_msg.cookie.mbx.chnl_retval);
@@ -323,7 +323,7 @@ idpf_vc_caps_get(struct idpf_adapter *adapter)
                return err;
        }
 
-       rte_memcpy(&adapter->caps, args.out_buffer, sizeof(struct 
virtchnl2_get_capabilities));
+       memcpy(&adapter->caps, args.out_buffer, sizeof(struct 
virtchnl2_get_capabilities));
 
        return 0;
 }
@@ -361,7 +361,7 @@ idpf_vc_vport_create(struct idpf_vport *vport,
                return err;
        }
 
-       rte_memcpy(&(vport->vport_info.info), args.out_buffer, 
IDPF_DFLT_MBX_BUF_SIZE);
+       memcpy(&(vport->vport_info.info), args.out_buffer, 
IDPF_DFLT_MBX_BUF_SIZE);
        return 0;
 }
 
@@ -419,7 +419,7 @@ idpf_vc_queue_grps_add(struct idpf_vport *vport,
                return err;
        }
 
-       rte_memcpy(p2p_queue_grps_out, args.out_buffer, IDPF_DFLT_MBX_BUF_SIZE);
+       memcpy(p2p_queue_grps_out, args.out_buffer, IDPF_DFLT_MBX_BUF_SIZE);
        return 0;
 }
 
@@ -475,7 +475,7 @@ idpf_vc_rss_key_set(struct idpf_vport *vport)
 
        rss_key->vport_id = vport->vport_id;
        rss_key->key_len = vport->rss_key_size;
-       rte_memcpy(rss_key->key, vport->rss_key,
+       memcpy(rss_key->key, vport->rss_key,
                   sizeof(rss_key->key[0]) * vport->rss_key_size);
 
        memset(&args, 0, sizeof(args));
@@ -528,7 +528,7 @@ int idpf_vc_rss_key_get(struct idpf_vport *vport)
                                return -ENOMEM;
                        }
                }
-               rte_memcpy(vport->rss_key, rss_key_ret->key, 
vport->rss_key_size);
+               memcpy(vport->rss_key, rss_key_ret->key, vport->rss_key_size);
        } else {
                DRV_LOG(ERR, "Failed to execute command of 
VIRTCHNL2_OP_GET_RSS_KEY");
        }
@@ -553,7 +553,7 @@ idpf_vc_rss_lut_set(struct idpf_vport *vport)
 
        rss_lut->vport_id = vport->vport_id;
        rss_lut->lut_entries = vport->rss_lut_size;
-       rte_memcpy(rss_lut->lut, vport->rss_lut,
+       memcpy(rss_lut->lut, vport->rss_lut,
                   sizeof(rss_lut->lut[0]) * vport->rss_lut_size);
 
        memset(&args, 0, sizeof(args));
@@ -605,7 +605,7 @@ idpf_vc_rss_lut_get(struct idpf_vport *vport)
                                return -ENOMEM;
                        }
                }
-               rte_memcpy(vport->rss_lut, rss_lut_ret->lut, 
rss_lut_ret->lut_entries);
+               memcpy(vport->rss_lut, rss_lut_ret->lut, 
rss_lut_ret->lut_entries);
                vport->rss_lut_size = rss_lut_ret->lut_entries;
        } else {
                DRV_LOG(ERR, "Failed to execute command of 
VIRTCHNL2_OP_GET_RSS_LUT");
@@ -742,7 +742,7 @@ idpf_vc_vectors_alloc(struct idpf_vport *vport, uint16_t 
num_vectors)
        if (err != 0)
                DRV_LOG(ERR, "Failed to execute command 
VIRTCHNL2_OP_ALLOC_VECTORS");
 
-       rte_memcpy(vport->recv_vectors, args.out_buffer, len);
+       memcpy(vport->recv_vectors, args.out_buffer, len);
        rte_free(alloc_vec);
        return err;
 }
@@ -1007,7 +1007,7 @@ idpf_vc_ptype_info_query(struct idpf_adapter *adapter,
        if (err != 0)
                DRV_LOG(ERR, "Failed to execute command of 
VIRTCHNL2_OP_GET_PTYPE_INFO");
 
-       rte_memcpy(recv_ptype_info, args.out_buffer, IDPF_DFLT_MBX_BUF_SIZE);
+       memcpy(recv_ptype_info, args.out_buffer, IDPF_DFLT_MBX_BUF_SIZE);
        return err;
 }
 
diff --git a/drivers/net/intel/idpf/idpf_ethdev.c 
b/drivers/net/intel/idpf/idpf_ethdev.c
index 5e57a45775..6b3016ba77 100644
--- a/drivers/net/intel/idpf/idpf_ethdev.c
+++ b/drivers/net/intel/idpf/idpf_ethdev.c
@@ -439,7 +439,7 @@ idpf_init_rss(struct idpf_vport *vport)
                             vport->rss_key_size);
                return -EINVAL;
        } else {
-               rte_memcpy(vport->rss_key, rss_conf->rss_key,
+               memcpy(vport->rss_key, rss_conf->rss_key,
                           vport->rss_key_size);
        }
 
@@ -558,7 +558,7 @@ idpf_rss_hash_update(struct rte_eth_dev *dev,
                return -EINVAL;
        }
 
-       rte_memcpy(vport->rss_key, rss_conf->rss_key,
+       memcpy(vport->rss_key, rss_conf->rss_key,
                   vport->rss_key_size);
        ret = idpf_vc_rss_key_set(vport);
        if (ret != 0) {
@@ -631,7 +631,7 @@ idpf_rss_hash_conf_get(struct rte_eth_dev *dev,
        if (rss_conf->rss_key_len > vport->rss_key_size)
                rss_conf->rss_key_len = vport->rss_key_size;
 
-       rte_memcpy(rss_conf->rss_key, vport->rss_key, rss_conf->rss_key_len);
+       memcpy(rss_conf->rss_key, vport->rss_key, rss_conf->rss_key_len);
 
        return 0;
 }
@@ -1363,7 +1363,7 @@ idpf_handle_virtchnl_msg(struct idpf_adapter_ext 
*adapter_ex)
                        return;
                }
 
-               rte_memcpy(adapter->mbx_resp, ctlq_msg.ctx.indirect.payload->va,
+               memcpy(adapter->mbx_resp, ctlq_msg.ctx.indirect.payload->va,
                           IDPF_DFLT_MBX_BUF_SIZE);
 
                mbx_op = rte_le_to_cpu_16(ctlq_msg.opcode);
@@ -1477,7 +1477,7 @@ idpf_adapter_ext_init(struct rte_pci_device *pci_dev, 
struct idpf_adapter_ext *a
 
        strncpy(adapter->name, pci_dev->device.name, PCI_PRI_STR_SIZE);
 
-       rte_memcpy(&base->caps, &req_caps, sizeof(struct 
virtchnl2_get_capabilities));
+       memcpy(&base->caps, &req_caps, sizeof(struct 
virtchnl2_get_capabilities));
 
        ret = idpf_adapter_init(base);
        if (ret != 0) {
diff --git a/drivers/net/intel/idpf/idpf_rxtx.c 
b/drivers/net/intel/idpf/idpf_rxtx.c
index b316c77b62..07f3df4a80 100644
--- a/drivers/net/intel/idpf/idpf_rxtx.c
+++ b/drivers/net/intel/idpf/idpf_rxtx.c
@@ -74,7 +74,7 @@ idpf_dma_zone_reserve(struct rte_eth_dev *dev, uint16_t 
queue_idx,
                else
                        ring_size = RTE_ALIGN(len * sizeof(struct ci_tx_desc),
                                              IDPF_DMA_MEM_ALIGN);
-               rte_memcpy(ring_name, "idpf Tx ring", sizeof("idpf Tx ring"));
+               memcpy(ring_name, "idpf Tx ring", sizeof("idpf Tx ring"));
                break;
        case VIRTCHNL2_QUEUE_TYPE_RX:
                if (splitq)
@@ -83,17 +83,17 @@ idpf_dma_zone_reserve(struct rte_eth_dev *dev, uint16_t 
queue_idx,
                else
                        ring_size = RTE_ALIGN(len * sizeof(struct 
virtchnl2_singleq_rx_buf_desc),
                                              IDPF_DMA_MEM_ALIGN);
-               rte_memcpy(ring_name, "idpf Rx ring", sizeof("idpf Rx ring"));
+               memcpy(ring_name, "idpf Rx ring", sizeof("idpf Rx ring"));
                break;
        case VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION:
                ring_size = RTE_ALIGN(len * sizeof(struct 
idpf_splitq_tx_compl_desc),
                                      IDPF_DMA_MEM_ALIGN);
-               rte_memcpy(ring_name, "idpf Tx compl ring", sizeof("idpf Tx 
compl ring"));
+               memcpy(ring_name, "idpf Tx compl ring", sizeof("idpf Tx compl 
ring"));
                break;
        case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER:
                ring_size = RTE_ALIGN(len * sizeof(struct 
virtchnl2_splitq_rx_buf_desc),
                                      IDPF_DMA_MEM_ALIGN);
-               rte_memcpy(ring_name, "idpf Rx buf ring", sizeof("idpf Rx buf 
ring"));
+               memcpy(ring_name, "idpf Rx buf ring", sizeof("idpf Rx buf 
ring"));
                break;
        default:
                PMD_INIT_LOG(ERR, "Invalid queue type");
-- 
2.51.0

Reply via email to