For example when PF is reset, the PF sends a message to notify VFs of
 this event and also trigger an interrupt to VFs. Then in the interrupt
 service routine the VFs detects this notification message and calls
-_rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET, NULL,
-NULL). This means that a PF reset triggers an RTE_ETH_EVENT_INTR_RESET
+_rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET, NULL).
+This means that a PF reset triggers an RTE_ETH_EVENT_INTR_RESET
 event within VFs. The function _rte_eth_dev_callback_process() will
 call the registered callback function. The callback function can trigger
 the application to handle all operations the VF reset requires including
 
        case VIRTCHNL_EVENT_RESET_IMPENDING:
                PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_RESET_IMPENDING event");
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET,
-                                             NULL, NULL);
+                                             NULL);
                break;
        case VIRTCHNL_EVENT_LINK_CHANGE:
                PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_LINK_CHANGE event");
                vf->link_speed = pf_msg->event_data.link_event.link_speed;
                avf_dev_link_update(dev, 0);
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
                break;
        case VIRTCHNL_EVENT_PF_DRIVER_CLOSE:
                PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_PF_DRIVER_CLOSE event");
 
        ret_param.msg = msg;
 
        _rte_eth_dev_callback_process(bp->eth_dev, RTE_ETH_EVENT_VF_MBOX,
-                                     NULL, &ret_param);
+                                     &ret_param);
 
        /* Default to approve */
        if (ret_param.retval == RTE_PMD_BNXT_MB_EVENT_PROCEED)
 
                return;
 
        _rte_eth_dev_callback_process((struct rte_eth_dev *)arg,
-                       RTE_ETH_EVENT_INTR_LSC, NULL, NULL);
+                       RTE_ETH_EVENT_INTR_LSC, NULL);
 }
 
 int
                        else
                                _rte_eth_dev_callback_process(bonded_eth_dev,
                                                RTE_ETH_EVENT_INTR_LSC,
-                                               NULL, NULL);
+                                               NULL);
 
                } else {
                        if (internals->link_down_delay_ms > 0)
                        else
                                _rte_eth_dev_callback_process(bonded_eth_dev,
                                                RTE_ETH_EVENT_INTR_LSC,
-                                               NULL, NULL);
+                                               NULL);
                }
        }
        return 0;
 
                dpaa2_dev_link_update(dev, 0);
                /* calling all the apps registered for link status event */
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 out:
        ret = dpni_clear_irq_status(dpni, CMD_PRI_LOW, priv->token,
 
 
        eth_em_interrupt_get_status(dev);
        eth_em_interrupt_action(dev, dev->intr_handle);
-       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL, NULL);
+       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
 }
 
 static int
 
                E1000_WRITE_REG(hw, E1000_RCTL, rctl);
                E1000_WRITE_FLUSH(hw);
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 
        return 0;
        /* PF reset VF event */
        if (in_msg == E1000_PF_CONTROL_MSG)
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET,
-                                             NULL, NULL);
+                                             NULL);
 }
 
 static int
 
        vnic_intr_return_all_credits(&enic->intr);
 
        enic_link_update(enic);
-       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL, NULL);
+       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
        enic_log_q_error(enic);
 }
 
 
        if (ret)
                return _rte_eth_dev_callback_process(dev,
                                                     RTE_ETH_EVENT_INTR_LSC,
-                                                    NULL, NULL);
+                                                    NULL);
        else
                return 0;
 }
 
                        dev_info->sm_down = 0;
                        _rte_eth_dev_callback_process(dev,
                                        RTE_ETH_EVENT_INTR_LSC,
-                                       NULL, NULL);
+                                       NULL);
                }
        }
 
                PMD_INIT_LOG(INFO, "INT: Switch is down");
                dev_info->sm_down = 1;
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                               NULL, NULL);
+                               NULL);
        }
 
        /* Handle SRAM error */
                /* Setting reset flag */
                dev_info->sm_down = 1;
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                               NULL, NULL);
+                               NULL);
        }
 
        if (dev_info->sm_down == 1 &&
 
                dev_info->sm_down = 0;
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                               NULL, NULL);
+                               NULL);
        }
 
        /* Re-enable interrupt from device side */
 
                        ret = i40e_dev_link_update(dev, 0);
                        if (!ret)
                                _rte_eth_dev_callback_process(dev,
-                                       RTE_ETH_EVENT_INTR_LSC, NULL, NULL);
+                                       RTE_ETH_EVENT_INTR_LSC, NULL);
                        break;
                default:
                        PMD_DRV_LOG(DEBUG, "Request %u is not supported yet",
 
        case VIRTCHNL_EVENT_RESET_IMPENDING:
                PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_RESET_IMPENDING event");
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET,
-                                             NULL, NULL);
+                                             NULL);
                break;
        case VIRTCHNL_EVENT_LINK_CHANGE:
                PMD_DRV_LOG(DEBUG, "VIRTCHNL_EVENT_LINK_CHANGE event");
 
         * do nothing and send not_supported to VF. As PF must send a response
         * to VF and ACK/NACK is not defined.
         */
-       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_VF_MBOX,
-                                     NULL, &ret_param);
+       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_VF_MBOX, &ret_param);
        if (ret_param.retval != RTE_PMD_I40E_MB_EVENT_PROCEED) {
                PMD_DRV_LOG(WARNING, "VF to PF message(%d) is not permitted!",
                            opcode);
 
                intr->flags &= ~IXGBE_FLAG_NEED_LINK_UPDATE;
                ixgbe_dev_link_status_print(dev);
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 
        if (intr->flags & IXGBE_FLAG_MACSEC) {
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_MACSEC,
-                                             NULL, NULL);
+                                             NULL);
                intr->flags &= ~IXGBE_FLAG_MACSEC;
        }
 
        /* PF reset VF event */
        if (in_msg == IXGBE_PF_CONTROL_MSG)
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RESET,
-                                             NULL, NULL);
+                                             NULL);
 }
 
 static int
 
 
                /* notify application about VF reset */
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_VF_MBOX,
-                                             NULL, &ret_param);
+                                             &ret_param);
                return ret;
        }
 
         * if ret_param.retval > 1, do nothing and send NAK to VF
         */
        _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_VF_MBOX,
-                                     NULL, &ret_param);
+                                     &ret_param);
 
        retval = ret_param.retval;
 
 
        if (intr_conf->lsc && !mlx4_link_status_check(priv))
                _rte_eth_dev_callback_process(priv->dev,
                                              RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
 }
 
 /**
        for (i = 0; i != RTE_DIM(caught); ++i)
                if (caught[i])
                        _rte_eth_dev_callback_process(priv->dev, type[i],
-                                                     NULL, NULL);
+                                                     NULL);
 }
 
 /**
 
        ret = priv_link_status_update(priv);
        priv_unlock(priv);
        if (!ret)
-               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL,
-                                             NULL);
+               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
 }
 
 /**
        events = priv_dev_status_handler(priv);
        priv_unlock(priv);
        if (events & (1 << RTE_ETH_EVENT_INTR_LSC))
-               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL,
-                                             NULL);
+               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
        if (events & (1 << RTE_ETH_EVENT_INTR_RMV))
-               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RMV, NULL,
-                                             NULL);
+               _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_RMV, NULL);
 }
 
 /**
 
        struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
 
        nfp_net_link_update(dev, 0);
-       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL, NULL);
+       _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
 
        nfp_net_dev_link_status_print(dev);
 
 
                         "UP" : "DOWN");
                _rte_eth_dev_callback_process(sa->eth_dev,
                                              RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 }
 
                sfc_info(sa, "link status change event");
                _rte_eth_dev_callback_process(sa->eth_dev,
                                              RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 }
 
 
                if (dev->data->dev_conf.intr_conf.lsc)
                        nicvf_set_eth_link_status(nic, &dev->data->dev_link);
                _rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC,
-                                             NULL, NULL);
+                                             NULL);
        }
 
        rte_eal_alarm_set(NICVF_INTR_POLL_INTERVAL_MS * 1000,
 
 
        RTE_LOG(INFO, PMD, "New connection established\n");
 
-       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_INTR_LSC,
-                                     NULL, NULL);
+       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_INTR_LSC, NULL);
 
        return 0;
 }
 
        RTE_LOG(INFO, PMD, "Connection closed\n");
 
-       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_INTR_LSC,
-                                     NULL, NULL);
+       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_INTR_LSC, NULL);
 }
 
 static int
        RTE_LOG(INFO, PMD, "vring%u is %s\n",
                        vring, enable ? "enabled" : "disabled");
 
-       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_QUEUE_STATE,
-                                     NULL, NULL);
+       _rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_QUEUE_STATE, NULL);
 
        return 0;
 }
 
                if (virtio_dev_link_update(dev, 0) == 0)
                        _rte_eth_dev_callback_process(dev,
                                                      RTE_ETH_EVENT_INTR_LSC,
-                                                     NULL, NULL);
+                                                     NULL);
        }
 
 }
 
                if (vmxnet3_dev_link_update(dev, 0) == 0)
                        _rte_eth_dev_callback_process(dev,
                                                      RTE_ETH_EVENT_INTR_LSC,
-                                                     NULL, NULL);
+                                                     NULL);
        }
 
        /* Check if there is an error on xmit/recv queues */
 
 
 int
 _rte_eth_dev_callback_process(struct rte_eth_dev *dev,
-       enum rte_eth_event_type event, void *cb_arg, void *ret_param)
+       enum rte_eth_event_type event, void *ret_param)
 {
        struct rte_eth_dev_callback *cb_lst;
        struct rte_eth_dev_callback dev_cb;
                        continue;
                dev_cb = *cb_lst;
                cb_lst->active = 1;
-               if (cb_arg != NULL)
-                       dev_cb.cb_arg = cb_arg;
                if (ret_param != NULL)
                        dev_cb.ret_param = ret_param;
 
 
  *  Pointer to struct rte_eth_dev.
  * @param event
  *  Eth device interrupt event type.
- * @param cb_arg
- *  callback parameter.
  * @param ret_param
  *  To pass data back to user application.
  *  This allows the user application to decide if a particular function
  *  int
  */
 int _rte_eth_dev_callback_process(struct rte_eth_dev *dev,
-               enum rte_eth_event_type event, void *cb_arg, void *ret_param);
+               enum rte_eth_event_type event, void *ret_param);
 
 /**
  * When there is no rx packet coming in Rx Queue for a long time, we can
 
        vrtl_eth_dev->data->dev_link.link_status = link_status;
 
        _rte_eth_dev_callback_process(vrtl_eth_dev, RTE_ETH_EVENT_INTR_LSC,
-                                     NULL, NULL);
+                                     NULL);
 }
 
 int