PMD_DRV_LOG(ERR, "failed to allocate memory");
                                goto out;
                        }
-                       (void)rte_memcpy(&ntuple_filter_ptr->filter_info,
+                       rte_memcpy(&ntuple_filter_ptr->filter_info,
                                &ntuple_filter,
                                sizeof(struct rte_eth_ntuple_filter));
                        TAILQ_INSERT_TAIL(&filter_ntuple_list,
                                PMD_DRV_LOG(ERR, "failed to allocate memory");
                                goto out;
                        }
-                       (void)rte_memcpy(ðertype_filter_ptr->filter_info,
+                       rte_memcpy(ðertype_filter_ptr->filter_info,
                                ðertype_filter,
                                sizeof(struct rte_eth_ethertype_filter));
                        TAILQ_INSERT_TAIL(&filter_ethertype_list,
                                PMD_DRV_LOG(ERR, "failed to allocate memory");
                                goto out;
                        }
-                       (void)rte_memcpy(&syn_filter_ptr->filter_info,
+                       rte_memcpy(&syn_filter_ptr->filter_info,
                                &syn_filter,
                                sizeof(struct rte_eth_syn_filter));
                        TAILQ_INSERT_TAIL(&filter_syn_list,
                                        PMD_DRV_LOG(ERR, "failed to allocate memory");
                                        goto out;
                                }
-                               (void)rte_memcpy(&fdir_rule_ptr->filter_info,
+                               rte_memcpy(&fdir_rule_ptr->filter_info,
                                        &fdir_rule,
                                        sizeof(struct ixgbe_fdir_rule));
                                TAILQ_INSERT_TAIL(&filter_fdir_list,
                                PMD_DRV_LOG(ERR, "failed to allocate memory");
                                goto out;
                        }
-                       (void)rte_memcpy(&l2_tn_filter_ptr->filter_info,
+                       rte_memcpy(&l2_tn_filter_ptr->filter_info,
                                &l2_tn_filter,
                                sizeof(struct rte_eth_l2_tunnel_conf));
                        TAILQ_INSERT_TAIL(&filter_l2_tunnel_list,
        case RTE_ETH_FILTER_NTUPLE:
                ntuple_filter_ptr = (struct ixgbe_ntuple_filter_ele *)
                                        pmd_flow->rule;
-               (void)rte_memcpy(&ntuple_filter,
+               rte_memcpy(&ntuple_filter,
                        &ntuple_filter_ptr->filter_info,
                        sizeof(struct rte_eth_ntuple_filter));
                ret = ixgbe_add_del_ntuple_filter(dev, &ntuple_filter, FALSE);
        case RTE_ETH_FILTER_ETHERTYPE:
                ethertype_filter_ptr = (struct ixgbe_ethertype_filter_ele *)
                                        pmd_flow->rule;
-               (void)rte_memcpy(ðertype_filter,
+               rte_memcpy(ðertype_filter,
                        ðertype_filter_ptr->filter_info,
                        sizeof(struct rte_eth_ethertype_filter));
                ret = ixgbe_add_del_ethertype_filter(dev,
        case RTE_ETH_FILTER_SYN:
                syn_filter_ptr = (struct ixgbe_eth_syn_filter_ele *)
                                pmd_flow->rule;
-               (void)rte_memcpy(&syn_filter,
+               rte_memcpy(&syn_filter,
                        &syn_filter_ptr->filter_info,
                        sizeof(struct rte_eth_syn_filter));
                ret = ixgbe_syn_filter_set(dev, &syn_filter, FALSE);
                break;
        case RTE_ETH_FILTER_FDIR:
                fdir_rule_ptr = (struct ixgbe_fdir_rule_ele *)pmd_flow->rule;
-               (void)rte_memcpy(&fdir_rule,
+               rte_memcpy(&fdir_rule,
                        &fdir_rule_ptr->filter_info,
                        sizeof(struct ixgbe_fdir_rule));
                ret = ixgbe_fdir_filter_program(dev, &fdir_rule, TRUE, FALSE);
        case RTE_ETH_FILTER_L2_TUNNEL:
                l2_tn_filter_ptr = (struct ixgbe_eth_l2_tunnel_conf_ele *)
                                pmd_flow->rule;
-               (void)rte_memcpy(&l2_tn_filter, &l2_tn_filter_ptr->filter_info,
+               rte_memcpy(&l2_tn_filter, &l2_tn_filter_ptr->filter_info,
                        sizeof(struct rte_eth_l2_tunnel_conf));
                ret = ixgbe_dev_l2_tunnel_filter_del(dev, &l2_tn_filter);
                if (!ret) {
 
        if (!shaper_profile)
                return -ENOMEM;
        shaper_profile->shaper_profile_id = shaper_profile_id;
-       (void)rte_memcpy(&shaper_profile->profile, profile,
+       rte_memcpy(&shaper_profile->profile, profile,
                         sizeof(struct rte_tm_shaper_params));
        TAILQ_INSERT_TAIL(&tm_conf->shaper_profile_list,
                          shaper_profile, node);
                tm_node->no = 0;
                tm_node->parent = NULL;
                tm_node->shaper_profile = shaper_profile;
-               (void)rte_memcpy(&tm_node->params, params,
+               rte_memcpy(&tm_node->params, params,
                                 sizeof(struct rte_tm_node_params));
                tm_conf->root = tm_node;
 
        tm_node->reference_count = 0;
        tm_node->parent = parent_node;
        tm_node->shaper_profile = shaper_profile;
-       (void)rte_memcpy(&tm_node->params, params,
+       rte_memcpy(&tm_node->params, params,
                         sizeof(struct rte_tm_node_params));
        if (parent_node_type == IXGBE_TM_NODE_TYPE_PORT) {
                tm_node->no = parent_node->reference_count;