#include <linux/mlx5/driver.h>
 #include "mlx5_core.h"
-#include "lib/mlx5.h"
 
 static LIST_HEAD(intf_list);
 static LIST_HEAD(mlx5_dev_list);
        unsigned long           state;
 };
 
-struct mlx5_delayed_event {
-       struct list_head        list;
-       struct mlx5_core_dev    *dev;
-       enum mlx5_dev_event     event;
-       unsigned long           param;
-};
-
 enum {
        MLX5_INTERFACE_ADDED,
        MLX5_INTERFACE_ATTACHED,
 };
 
-static void add_delayed_event(struct mlx5_priv *priv,
-                             struct mlx5_core_dev *dev,
-                             enum mlx5_dev_event event,
-                             unsigned long param)
-{
-       struct mlx5_delayed_event *delayed_event;
-
-       delayed_event = kzalloc(sizeof(*delayed_event), GFP_ATOMIC);
-       if (!delayed_event) {
-               mlx5_core_err(dev, "event %d is missed\n", event);
-               return;
-       }
-
-       mlx5_core_dbg(dev, "Accumulating event %d\n", event);
-       delayed_event->dev = dev;
-       delayed_event->event = event;
-       delayed_event->param = param;
-       list_add_tail(&delayed_event->list, &priv->waiting_events_list);
-}
-
-static void delayed_event_release(struct mlx5_device_context *dev_ctx,
-                                 struct mlx5_priv *priv)
-{
-       struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev, priv);
-       struct mlx5_delayed_event *de;
-       struct mlx5_delayed_event *n;
-       struct list_head temp;
-
-       INIT_LIST_HEAD(&temp);
-
-       spin_lock_irq(&priv->ctx_lock);
-
-       priv->is_accum_events = false;
-       list_splice_init(&priv->waiting_events_list, &temp);
-       if (!dev_ctx->context)
-               goto out;
-       list_for_each_entry_safe(de, n, &temp, list)
-               dev_ctx->intf->event(dev, dev_ctx->context, de->event, de->param);
-
-out:
-       spin_unlock_irq(&priv->ctx_lock);
-
-       list_for_each_entry_safe(de, n, &temp, list) {
-               list_del(&de->list);
-               kfree(de);
-       }
-}
-
-/* accumulating events that can come after mlx5_ib calls to
- * ib_register_device, till adding that interface to the events list.
- */
-static void delayed_event_start(struct mlx5_priv *priv)
-{
-       spin_lock_irq(&priv->ctx_lock);
-       priv->is_accum_events = true;
-       spin_unlock_irq(&priv->ctx_lock);
-}
 
 void mlx5_add_device(struct mlx5_interface *intf, struct mlx5_priv *priv)
 {
 
        dev_ctx->intf = intf;
 
-       delayed_event_start(priv);
-
        dev_ctx->context = intf->add(dev);
        if (dev_ctx->context) {
                set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state);
                spin_unlock_irq(&priv->ctx_lock);
        }
 
-       delayed_event_release(dev_ctx, priv);
-
        if (!dev_ctx->context)
                kfree(dev_ctx);
 }
        if (!dev_ctx)
                return;
 
-       delayed_event_start(priv);
        if (intf->attach) {
                if (test_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state))
-                       goto out;
+                       return;
                if (intf->attach(dev, dev_ctx->context))
-                       goto out;
-
+                       return;
                set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state);
        } else {
                if (test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state))
-                       goto out;
+                       return;
                dev_ctx->context = intf->add(dev);
                if (!dev_ctx->context)
-                       goto out;
-
+                       return;
                set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state);
        }
-
-out:
-       delayed_event_release(dev_ctx, priv);
 }
 
 void mlx5_attach_device(struct mlx5_core_dev *dev)
        return res;
 }
 
-void mlx5_core_event(struct mlx5_core_dev *dev, enum mlx5_dev_event event,
-                    unsigned long param)
-{
-       struct mlx5_priv *priv = &dev->priv;
-       struct mlx5_device_context *dev_ctx;
-       unsigned long flags;
-
-       spin_lock_irqsave(&priv->ctx_lock, flags);
-
-       if (priv->is_accum_events)
-               add_delayed_event(priv, dev, event, param);
-
-       /* After mlx5_detach_device, the dev_ctx->intf is still set and dev_ctx is
-        * still in priv->ctx_list. In this case, only notify the dev_ctx if its
-        * ADDED or ATTACHED bit are set.
-        */
-       list_for_each_entry(dev_ctx, &priv->ctx_list, list)
-               if (dev_ctx->intf->event &&
-                   (test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state) ||
-                    test_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state)))
-                       dev_ctx->intf->event(dev, dev_ctx->context, event, param);
-
-       spin_unlock_irqrestore(&priv->ctx_lock, flags);
-
-       mlx5_notifier_call_chain(dev->priv.events, event, (void *)param);
-}
 
 void mlx5_dev_list_lock(void)
 {
 
        return err;
 }
 
-struct mlx5_core_event_handler {
-       void (*event)(struct mlx5_core_dev *dev,
-                     enum mlx5_dev_event event,
-                     void *data);
-};
-
 static const struct devlink_ops mlx5_devlink_ops = {
 #ifdef CONFIG_MLX5_ESWITCH
        .eswitch_mode_set = mlx5_devlink_eswitch_mode_set,
        pci_set_drvdata(pdev, dev);
 
        dev->pdev = pdev;
-       dev->event = mlx5_core_event;
        dev->profile = &profile[prof_sel];
 
        INIT_LIST_HEAD(&priv->ctx_list);
        mutex_init(&dev->pci_status_mutex);
        mutex_init(&dev->intf_state_mutex);
 
-       INIT_LIST_HEAD(&priv->waiting_events_list);
-       priv->is_accum_events = false;
-
        mutex_init(&priv->bfregs.reg_head.lock);
        mutex_init(&priv->bfregs.wc_head.lock);
        INIT_LIST_HEAD(&priv->bfregs.reg_head.list);
 
        struct list_head        dev_list;
        struct list_head        ctx_list;
        spinlock_t              ctx_lock;
-
-       struct list_head        waiting_events_list;
-       bool                    is_accum_events;
-       struct mlx5_events     *events;
+       struct mlx5_events      *events;
 
        struct mlx5_flow_steering *steering;
        struct mlx5_mpfs        *mpfs;
        /* sync interface state */
        struct mutex            intf_state_mutex;
        unsigned long           intf_state;
-       void                    (*event) (struct mlx5_core_dev *dev,
-                                         enum mlx5_dev_event event,
-                                         unsigned long param);
        struct mlx5_priv        priv;
        struct mlx5_profile     *profile;
        atomic_t                num_qps;
        void                    (*remove)(struct mlx5_core_dev *dev, void *context);
        int                     (*attach)(struct mlx5_core_dev *dev, void *context);
        void                    (*detach)(struct mlx5_core_dev *dev, void *context);
-       void                    (*event)(struct mlx5_core_dev *dev, void *context,
-                                        enum mlx5_dev_event event, unsigned long param);
        void *                  (*get_dev)(void *context);
        int                     protocol;
        struct list_head        list;