struct net_device *net_dev;
 
        spinlock_t lock;
-       struct net_device_stats stats;
 
        /* RX context handling */
        struct sk_buff *rx_skb;
 extern int i1480u_hard_start_xmit(struct sk_buff *, struct net_device *);
 extern void i1480u_tx_timeout(struct net_device *);
 extern int i1480u_set_config(struct net_device *, struct ifmap *);
-extern struct net_device_stats *i1480u_get_stats(struct net_device *);
 extern int i1480u_change_mtu(struct net_device *, int);
 extern void i1480u_uwb_notifs_cb(void *, struct uwb_dev *, enum uwb_notifs);
 
 
 }
 #endif
 
+static const struct net_device_ops i1480u_netdev_ops = {
+       .ndo_open       = i1480u_open,
+       .ndo_stop       = i1480u_stop,
+       .ndo_start_xmit = i1480u_hard_start_xmit,
+       .ndo_tx_timeout = i1480u_tx_timeout,
+       .ndo_set_config = i1480u_set_config,
+       .ndo_change_mtu = i1480u_change_mtu,
+};
+
 static
 int i1480u_add(struct i1480u *i1480u, struct usb_interface *iface)
 {
        net_dev->features |= NETIF_F_HIGHDMA;
        net_dev->watchdog_timeo = 5*HZ;         /* FIXME: a better default? */
 
-       net_dev->open = i1480u_open;
-       net_dev->stop = i1480u_stop;
-       net_dev->hard_start_xmit = i1480u_hard_start_xmit;
-       net_dev->tx_timeout = i1480u_tx_timeout;
-       net_dev->get_stats = i1480u_get_stats;
-       net_dev->set_config = i1480u_set_config;
-       net_dev->change_mtu = i1480u_change_mtu;
+       net_dev->netdev_ops = &i1480u_netdev_ops;
 
 #ifdef i1480u_FLOW_CONTROL
        /* Notification endpoint setup (submitted when we open the device) */
 
        return 0;
 }
 
-
-/** Report statistics */
-struct net_device_stats *i1480u_get_stats(struct net_device *net_dev)
-{
-       struct i1480u *i1480u = netdev_priv(net_dev);
-       return &i1480u->stats;
-}
-
-
 /**
  *
  * Change the interface config--we probably don't have to do anything.
 
 do {                                                   \
        if (printk_ratelimit())                         \
                dev_err(&i1480u->usb_iface->dev, msg);  \
-       i1480u->stats.rx_dropped++;                     \
+       i1480u->net_dev->stats.rx_dropped++;                    \
 } while (0)
 
 
        if (!should_parse)
                goto out;
        i1480u->rx_skb->protocol = eth_type_trans(i1480u->rx_skb, net_dev);
-       i1480u->stats.rx_packets++;
-       i1480u->stats.rx_bytes += i1480u->rx_untd_pkt_size;
-       net_dev->last_rx = jiffies;
-       /* FIXME: flow control: check netif_rx() retval */
+       net_dev->stats.rx_packets++;
+       net_dev->stats.rx_bytes += i1480u->rx_untd_pkt_size;
 
        netif_rx(i1480u->rx_skb);               /* deliver */
 out:
 
        switch (urb->status) {
        case 0:
                spin_lock_irqsave(&i1480u->lock, flags);
-               i1480u->stats.tx_packets++;
-               i1480u->stats.tx_bytes += urb->actual_length;
+               net_dev->stats.tx_packets++;
+               net_dev->stats.tx_bytes += urb->actual_length;
                spin_unlock_irqrestore(&i1480u->lock, flags);
                break;
        case -ECONNRESET:       /* Not an error, but a controlled situation; */
        return NETDEV_TX_OK;
 error:
        dev_kfree_skb_any(skb);
-       i1480u->stats.tx_dropped++;
+       net_dev->stats.tx_dropped++;
 out:
        return NETDEV_TX_OK;
 }