static int
 simeth_device_event(struct notifier_block *this,unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct simeth_local *local;
        struct in_device *in_dev;
        struct in_ifaddr **ifap = NULL;
 
                               unsigned long event,
                               void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
+
        if (event == NETDEV_CHANGE && netif_carrier_ok(dev)) {
                __u64 bit = 0;
                if (dev->irq == TXX9_IRQ_BASE + TX4939_IR_ETH(0))
 
 }
 
 static int cma_netdev_callback(struct notifier_block *self, unsigned long event,
-                              void *ctx)
+                              void *ptr)
 {
-       struct net_device *ndev = (struct net_device *)ctx;
+       struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
        struct cma_device *cma_dev;
        struct rdma_id_private *id_priv;
        int ret = NOTIFY_DONE;
 
 static int mlx4_ib_netdev_event(struct notifier_block *this, unsigned long event,
                                void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct mlx4_ib_dev *ibdev;
        struct net_device *oldnd;
        struct mlx4_ib_iboe *iboe;
 
 static int bond_netdev_event(struct notifier_block *this,
                             unsigned long event, void *ptr)
 {
-       struct net_device *event_dev = (struct net_device *)ptr;
+       struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
 
        pr_debug("event_dev: %s, event: %lx\n",
                 event_dev ? event_dev->name : "None",
 
 
 /* NETDEV rename notifier to rename the associated led triggers too */
 static int can_led_notifier(struct notifier_block *nb, unsigned long msg,
-                       void *data)
+                           void *ptr)
 {
-       struct net_device *netdev = data;
+       struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
        struct can_priv *priv = safe_candev_priv(netdev);
        char name[CAN_LED_NAME_SZ];
 
 
 static int cnic_netdev_event(struct notifier_block *this, unsigned long event,
                                                         void *ptr)
 {
-       struct net_device *netdev = ptr;
+       struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
        struct cnic_dev *dev;
        int new_dev = 0;
 
 
 static int skge_device_event(struct notifier_block *unused,
                             unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct skge_port *skge;
        struct dentry *d;
 
 
 static int sky2_device_event(struct notifier_block *unused,
                             unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct sky2_port *sky2 = netdev_priv(dev);
 
        if (dev->netdev_ops->ndo_open != sky2_open || !sky2_debug)
 
                                 unsigned long event, void *ptr)
 {
        struct netxen_adapter *adapter;
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net_device *orig_dev = dev;
        struct net_device *slave;
 
 
                                 unsigned long event, void *ptr)
 {
        struct qlcnic_adapter *adapter;
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
 recheck:
        if (dev == NULL)
 
 static int efx_netdev_event(struct notifier_block *this,
                            unsigned long event, void *ptr)
 {
-       struct net_device *net_dev = ptr;
+       struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
 
        if (net_dev->netdev_ops == &efx_netdev_ops &&
            event == NETDEV_CHANGENAME)
 
 };
 
 static struct notifier_block bpq_dev_notifier = {
-       .notifier_call =bpq_device_event,
+       .notifier_call = bpq_device_event,
 };
 
 
 /*
  *     Handle device status changes.
  */
-static int bpq_device_event(struct notifier_block *this,unsigned long event, void *ptr)
+static int bpq_device_event(struct notifier_block *this,
+                           unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 static int macvlan_device_event(struct notifier_block *unused,
                                unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct macvlan_dev *vlan, *next;
        struct macvlan_port *port;
        LIST_HEAD(list_kill);
 
 static int macvtap_device_event(struct notifier_block *unused,
                                unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct macvlan_dev *vlan;
        struct device *classdev;
        dev_t devt;
 
 
 /* Handle network interface device notifications */
 static int netconsole_netdev_event(struct notifier_block *this,
-                                  unsigned long event,
-                                  void *ptr)
+                                  unsigned long event, void *ptr)
 {
        unsigned long flags;
        struct netconsole_target *nt;
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        bool stopped = false;
 
        if (!(event == NETDEV_CHANGENAME || event == NETDEV_UNREGISTER ||
 
 static int pppoe_device_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        /* Only look at sockets that are using this specific device. */
        switch (event) {
 
 static int team_device_event(struct notifier_block *unused,
                             unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *) ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct team_port *port;
 
        port = team_port_get_rtnl(dev);
 
 static int dlci_dev_event(struct notifier_block *unused,
                          unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *) ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (dev_net(dev) != &init_net)
                return NOTIFY_DONE;
 
 static int hdlc_device_event(struct notifier_block *this, unsigned long event,
                             void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        hdlc_device *hdlc;
        unsigned long flags;
        int on;
 
                                unsigned long event, void *ptr)
 {
        struct lapbethdev *lapbeth;
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (dev_net(dev) != &init_net)
                return NOTIFY_DONE;
 
 {
        struct fcoe_ctlr_device *cdev;
        struct fc_lport *lport = NULL;
-       struct net_device *netdev = ptr;
+       struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
        struct fcoe_ctlr *ctlr;
        struct fcoe_interface *fcoe;
        struct fcoe_port *port;
 
 static int libfcoe_device_notification(struct notifier_block *notifier,
                                    ulong event, void *ptr)
 {
-       struct net_device *netdev = ptr;
+       struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
 
        switch (event) {
        case NETDEV_UNREGISTER:
 
  */
 static int
 uf_netdev_event(struct notifier_block *notif, unsigned long event, void* ptr) {
-    struct net_device *netdev = ptr;
+    struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
     netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(netdev);
     unifi_priv_t *priv = NULL;
     static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
 
 static int ft1000NotifyProc(struct notifier_block *this, unsigned long event,
                                void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct ft1000_info *info;
 
        info = netdev_priv(dev);
 
 static int
 ft1000NotifyProc(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct ft1000_info *info;
        struct proc_dir_entry *ft1000_proc_file;
 
 
 static int bp_device_event(struct notifier_block *unused,
                           unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        static bpctl_dev_t *pbpctl_dev = NULL, *pbpctl_dev_m = NULL;
        int dev_num = 0, ret = 0, ret_d = 0, time_left = 0;
        /* printk("BP_PROC_SUPPORT event =%d %s %d\n", event,dev->name, dev->ifindex ); */
 
 
 extern int register_netdevice_notifier(struct notifier_block *nb);
 extern int unregister_netdevice_notifier(struct notifier_block *nb);
+
+struct netdev_notifier_info {
+       struct net_device *dev;
+};
+
+static inline struct net_device *
+netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
+{
+       return info->dev;
+}
+
+extern int call_netdevice_notifiers_info(unsigned long val, struct net_device *dev,
+                                        struct netdev_notifier_info *info);
 extern int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
 
 
 
 static int vlan_device_event(struct notifier_block *unused, unsigned long event,
                             void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct vlan_group *grp;
        struct vlan_info *vlan_info;
        int i, flgs;
 
 static int aarp_device_event(struct notifier_block *this, unsigned long event,
                             void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        int ct;
 
        if (!net_eq(dev_net(dev), &init_net))
 
 static int ddp_device_event(struct notifier_block *this, unsigned long event,
                            void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 }
 
 static int clip_device_event(struct notifier_block *this, unsigned long event,
-                            void *arg)
+                            void *ptr)
 {
-       struct net_device *dev = arg;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 }
 
 static int mpoa_event_listener(struct notifier_block *mpoa_notifier,
-                              unsigned long event, void *dev_ptr)
+                              unsigned long event, void *ptr)
 {
-       struct net_device *dev;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct mpoa_client *mpc;
        struct lec_priv *priv;
 
-       dev = dev_ptr;
-
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 
  *     Handle device status changes.
  */
 static int ax25_device_event(struct notifier_block *this, unsigned long event,
-       void *ptr)
+                            void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 };
 
 static struct notifier_block ax25_dev_notifier = {
-       .notifier_call =ax25_device_event,
+       .notifier_call = ax25_device_event,
 };
 
 static int __init ax25_init(void)
 
 static int batadv_hard_if_event(struct notifier_block *this,
                                unsigned long event, void *ptr)
 {
-       struct net_device *net_dev = ptr;
+       struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
        struct batadv_hard_iface *hard_iface;
        struct batadv_hard_iface *primary_if = NULL;
        struct batadv_priv *bat_priv;
 
  */
 static int br_device_event(struct notifier_block *unused, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net_bridge_port *p;
        struct net_bridge *br;
        bool changed_addr;
 
 
 /* notify Caif of device events */
 static int caif_device_notify(struct notifier_block *me, unsigned long what,
-                             void *arg)
+                             void *ptr)
 {
-       struct net_device *dev = arg;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct caif_device_entry *caifd = NULL;
        struct caif_dev_common *caifdev;
        struct cfcnfg *cfg;
 
 };
 
 static int cfusbl_device_notify(struct notifier_block *me, unsigned long what,
-                               void *arg)
+                               void *ptr)
 {
-       struct net_device *dev = arg;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct caif_dev_common common;
        struct cflayer *layer, *link_support;
        struct usbnet *usbnet;
 
  * af_can notifier to create/remove CAN netdevice specific structs
  */
 static int can_notifier(struct notifier_block *nb, unsigned long msg,
-                       void *data)
+                       void *ptr)
 {
-       struct net_device *dev = (struct net_device *)data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct dev_rcv_lists *d;
 
        if (!net_eq(dev_net(dev), &init_net))
 
  * notification handler for netdevice status changes
  */
 static int bcm_notifier(struct notifier_block *nb, unsigned long msg,
-                       void *data)
+                       void *ptr)
 {
-       struct net_device *dev = (struct net_device *)data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct bcm_sock *bo = container_of(nb, struct bcm_sock, notifier);
        struct sock *sk = &bo->sk;
        struct bcm_op *op;
 
 }
 
 static int cgw_notifier(struct notifier_block *nb,
-                       unsigned long msg, void *data)
+                       unsigned long msg, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 }
 
 static int raw_notifier(struct notifier_block *nb,
-                       unsigned long msg, void *data)
+                       unsigned long msg, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct raw_sock *ro = container_of(nb, struct raw_sock, notifier);
        struct sock *sk = &ro->sk;
 
 
 }
 EXPORT_SYMBOL(dev_disable_lro);
 
+static void netdev_notifier_info_init(struct netdev_notifier_info *info,
+                                     struct net_device *dev)
+{
+       info->dev = dev;
+}
+
+static int call_netdevice_notifier(struct notifier_block *nb, unsigned long val,
+                                  struct net_device *dev)
+{
+       struct netdev_notifier_info info;
+
+       netdev_notifier_info_init(&info, dev);
+       return nb->notifier_call(nb, val, &info);
+}
 
 static int dev_boot_phase = 1;
 
                goto unlock;
        for_each_net(net) {
                for_each_netdev(net, dev) {
-                       err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
+                       err = call_netdevice_notifier(nb, NETDEV_REGISTER, dev);
                        err = notifier_to_errno(err);
                        if (err)
                                goto rollback;
                        if (!(dev->flags & IFF_UP))
                                continue;
 
-                       nb->notifier_call(nb, NETDEV_UP, dev);
+                       call_netdevice_notifier(nb, NETDEV_UP, dev);
                }
        }
 
                                goto outroll;
 
                        if (dev->flags & IFF_UP) {
-                               nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
-                               nb->notifier_call(nb, NETDEV_DOWN, dev);
+                               call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
+                                                       dev);
+                               call_netdevice_notifier(nb, NETDEV_DOWN, dev);
                        }
-                       nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
+                       call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
                }
        }
 
        for_each_net(net) {
                for_each_netdev(net, dev) {
                        if (dev->flags & IFF_UP) {
-                               nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
-                               nb->notifier_call(nb, NETDEV_DOWN, dev);
+                               call_netdevice_notifier(nb, NETDEV_GOING_DOWN,
+                                                       dev);
+                               call_netdevice_notifier(nb, NETDEV_DOWN, dev);
                        }
-                       nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
+                       call_netdevice_notifier(nb, NETDEV_UNREGISTER, dev);
                }
        }
 unlock:
 }
 EXPORT_SYMBOL(unregister_netdevice_notifier);
 
+/**
+ *     call_netdevice_notifiers_info - call all network notifier blocks
+ *     @val: value passed unmodified to notifier function
+ *     @dev: net_device pointer passed unmodified to notifier function
+ *     @info: notifier information data
+ *
+ *     Call all network notifier blocks.  Parameters and return value
+ *     are as for raw_notifier_call_chain().
+ */
+
+int call_netdevice_notifiers_info(unsigned long val, struct net_device *dev,
+                                 struct netdev_notifier_info *info)
+{
+       ASSERT_RTNL();
+       netdev_notifier_info_init(info, dev);
+       return raw_notifier_call_chain(&netdev_chain, val, info);
+}
+EXPORT_SYMBOL(call_netdevice_notifiers_info);
+
 /**
  *     call_netdevice_notifiers - call all network notifier blocks
  *      @val: value passed unmodified to notifier function
 
 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
 {
-       ASSERT_RTNL();
-       return raw_notifier_call_chain(&netdev_chain, val, dev);
+       struct netdev_notifier_info info;
+
+       return call_netdevice_notifiers_info(val, dev, &info);
 }
 EXPORT_SYMBOL(call_netdevice_notifiers);
 
 
 }
 
 static int dropmon_net_event(struct notifier_block *ev_block,
-                       unsigned long event, void *ptr)
+                            unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct dm_hw_stat_delta *new_stat = NULL;
        struct dm_hw_stat_delta *tmp;
 
 
 static int dst_dev_event(struct notifier_block *this, unsigned long event,
                         void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct dst_entry *dst, *last = NULL;
 
        switch (event) {
 
 
 
 static int fib_rules_event(struct notifier_block *this, unsigned long event,
-                           void *ptr)
+                          void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
        struct fib_rules_ops *ops;
 
 
 static int netprio_device_event(struct notifier_block *unused,
                                unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct netprio_map *old;
 
        /*
 
 static int pktgen_device_event(struct notifier_block *unused,
                               unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct pktgen_net *pn = net_generic(dev_net(dev), pg_net_id);
 
        if (pn->pktgen_exiting)
 
 
 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        switch (event) {
        case NETDEV_UP:
 
 }
 
 static int dn_device_event(struct notifier_block *this, unsigned long event,
-                       void *ptr)
+                          void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 }
 
 static int lowpan_device_event(struct notifier_block *unused,
-                               unsigned long event,
-                               void *ptr)
+                              unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        LIST_HEAD(del_list);
        struct lowpan_dev_record *entry, *tmp;
 
 
 static int arp_netdev_event(struct notifier_block *this, unsigned long event,
                            void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        switch (event) {
        case NETDEV_CHANGEADDR:
 
 static int inetdev_event(struct notifier_block *this, unsigned long event,
                         void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct in_device *in_dev = __in_dev_get_rtnl(dev);
 
        ASSERT_RTNL();
 
 
 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct in_device *in_dev;
        struct net *net = dev_net(dev);
 
 
 
 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
        struct mr_table *mrt;
        struct vif_device *v;
 
                             unsigned long event,
                             void *ptr)
 {
-       const struct net_device *dev = ptr;
+       const struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
 
        if (event == NETDEV_DOWN) {
 
 }
 
 static int addrconf_notify(struct notifier_block *this, unsigned long event,
-                          void *data)
+                          void *ptr)
 {
-       struct net_device *dev = (struct net_device *) data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct inet6_dev *idev = __in6_dev_get(dev);
        int run_pending = 0;
        int err;
 
 static int ip6mr_device_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
        struct mr6_table *mrt;
        struct mif_device *v;
 
 
 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
        struct inet6_dev *idev;
 
 
 static int masq_device_event(struct notifier_block *this,
                             unsigned long event, void *ptr)
 {
-       const struct net_device *dev = ptr;
+       const struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
 
        if (event == NETDEV_DOWN)
 
 }
 
 static int ip6_route_dev_notify(struct notifier_block *this,
-                               unsigned long event, void *data)
+                               unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
 
        if (event == NETDEV_REGISTER && (dev->flags & IFF_LOOPBACK)) {
 
 static int ipxitf_device_event(struct notifier_block *notifier,
                                unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct ipx_interface *i, *tmp;
 
        if (!net_eq(dev_net(dev), &init_net))
 
 static int afiucv_netdev_event(struct notifier_block *this,
                               unsigned long event, void *ptr)
 {
-       struct net_device *event_dev = (struct net_device *)ptr;
+       struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
        struct sock *sk;
        struct iucv_sock *iucv;
 
 
 }
 
 static int netdev_notify(struct notifier_block *nb,
-                        unsigned long state,
-                        void *ndev)
+                        unsigned long state, void *ptr)
 {
-       struct net_device *dev = ndev;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct ieee80211_sub_if_data *sdata;
 
        if (state != NETDEV_CHANGENAME)
 
  * Currently only NETDEV_DOWN is handled to release refs to cached dsts
  */
 static int ip_vs_dst_event(struct notifier_block *this, unsigned long event,
-                           void *ptr)
+                          void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
        struct netns_ipvs *ipvs = net_ipvs(net);
        struct ip_vs_service *svc;
 
 nfqnl_rcv_dev_event(struct notifier_block *this,
                    unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        /* Drop any packets associated with the downed device */
        if (event == NETDEV_DOWN)
 
 static int tee_netdev_event(struct notifier_block *this, unsigned long event,
                            void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct xt_tee_priv *priv;
 
        priv = container_of(this, struct xt_tee_priv, notifier);
 
  * netlbl_unlhsh_netdev_handler - Network device notification handler
  * @this: notifier block
  * @event: the event
- * @ptr: the network device (cast to void)
+ * @ptr: the netdevice notifier info (cast to void)
  *
  * Description:
  * Handle network device events, although at present all we care about is a
  *
  */
 static int netlbl_unlhsh_netdev_handler(struct notifier_block *this,
-                                       unsigned long event,
-                                       void *ptr)
+                                       unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct netlbl_unlhsh_iface *iface = NULL;
 
        if (!net_eq(dev_net(dev), &init_net))
 
  */
 static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
                           void *ptr)
 {
        struct ovs_net *ovs_net;
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct vport *vport = NULL;
 
        if (!ovs_is_internal_dev(dev))
 
 }
 
 
-static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
+static int packet_notifier(struct notifier_block *this,
+                          unsigned long msg, void *ptr)
 {
        struct sock *sk;
-       struct net_device *dev = data;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct net *net = dev_net(dev);
 
        rcu_read_lock();
 
 
 /* notify Phonet of device events */
 static int phonet_device_notify(struct notifier_block *me, unsigned long what,
-                               void *arg)
+                               void *ptr)
 {
-       struct net_device *dev = arg;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        switch (what) {
        case NETDEV_REGISTER:
 
 /*
  *     Handle device status changes.
  */
-static int rose_device_event(struct notifier_block *this, unsigned long event,
-       void *ptr)
+static int rose_device_event(struct notifier_block *this,
+                            unsigned long event, void *ptr)
 {
-       struct net_device *dev = (struct net_device *)ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (!net_eq(dev_net(dev), &init_net))
                return NOTIFY_DONE;
 
 static int mirred_device_event(struct notifier_block *unused,
                               unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct tcf_mirred *m;
 
        if (event == NETDEV_UNREGISTER)
 
  * specified device.
  */
 static int recv_notification(struct notifier_block *nb, unsigned long evt,
-                            void *dv)
+                            void *ptr)
 {
-       struct net_device *dev = (struct net_device *)dv;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct eth_bearer *eb_ptr = ð_bearers[0];
        struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS];
 
 
  * specified device.
  */
 static int recv_notification(struct notifier_block *nb, unsigned long evt,
-                            void *dv)
+                            void *ptr)
 {
-       struct net_device *dev = (struct net_device *)dv;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct ib_bearer *ib_ptr = &ib_bearers[0];
        struct ib_bearer *stop = &ib_bearers[MAX_IB_BEARERS];
 
 
 }
 
 static int cfg80211_netdev_notifier_call(struct notifier_block *nb,
-                                        unsigned long state,
-                                        void *ndev)
+                                        unsigned long state, void *ptr)
 {
-       struct net_device *dev = ndev;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct wireless_dev *wdev = dev->ieee80211_ptr;
        struct cfg80211_registered_device *rdev;
        int ret;
 
 static int x25_device_event(struct notifier_block *this, unsigned long event,
                            void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
        struct x25_neigh *nb;
 
        if (!net_eq(dev_net(dev), &init_net))
 
 
 static int xfrm_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        switch (event) {
        case NETDEV_DOWN:
 
 static int sel_netif_netdev_notifier_handler(struct notifier_block *this,
                                             unsigned long event, void *ptr)
 {
-       struct net_device *dev = ptr;
+       struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 
        if (dev_net(dev) != &init_net)
                return NOTIFY_DONE;