rx_queue = &channel->rx_queue;
        rx_queue->efx = efx;
-       setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
-                   (unsigned long)rx_queue);
+       timer_setup(&rx_queue->slow_fill, efx_rx_slow_fill, 0);
 
        return channel;
 }
        rx_queue = &channel->rx_queue;
        rx_queue->buffer = NULL;
        memset(&rx_queue->rxd, 0, sizeof(rx_queue->rxd));
-       setup_timer(&rx_queue->slow_fill, efx_rx_slow_fill,
-                   (unsigned long)rx_queue);
+       timer_setup(&rx_queue->slow_fill, efx_rx_slow_fill, 0);
 
        return channel;
 }
 
 void efx_init_rx_queue(struct efx_rx_queue *rx_queue);
 void efx_fini_rx_queue(struct efx_rx_queue *rx_queue);
 void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue, bool atomic);
-void efx_rx_slow_fill(unsigned long context);
+void efx_rx_slow_fill(struct timer_list *t);
 void __efx_rx_packet(struct efx_channel *channel);
 void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,
                   unsigned int n_frags, unsigned int len, u16 flags);
 
 
        rx_queue = &channel->rx_queue;
        rx_queue->efx = efx;
-       setup_timer(&rx_queue->slow_fill, ef4_rx_slow_fill,
-                   (unsigned long)rx_queue);
+       timer_setup(&rx_queue->slow_fill, ef4_rx_slow_fill, 0);
 
        return channel;
 }
        rx_queue = &channel->rx_queue;
        rx_queue->buffer = NULL;
        memset(&rx_queue->rxd, 0, sizeof(rx_queue->rxd));
-       setup_timer(&rx_queue->slow_fill, ef4_rx_slow_fill,
-                   (unsigned long)rx_queue);
+       timer_setup(&rx_queue->slow_fill, ef4_rx_slow_fill, 0);
 
        return channel;
 }
 
 void ef4_init_rx_queue(struct ef4_rx_queue *rx_queue);
 void ef4_fini_rx_queue(struct ef4_rx_queue *rx_queue);
 void ef4_fast_push_rx_descriptors(struct ef4_rx_queue *rx_queue, bool atomic);
-void ef4_rx_slow_fill(unsigned long context);
+void ef4_rx_slow_fill(struct timer_list *t);
 void __ef4_rx_packet(struct ef4_channel *channel);
 void ef4_rx_packet(struct ef4_rx_queue *rx_queue, unsigned int index,
                   unsigned int n_frags, unsigned int len, u16 flags);
 
        }
 }
 
-static void falcon_stats_timer_func(unsigned long context)
+static void falcon_stats_timer_func(struct timer_list *t)
 {
-       struct ef4_nic *efx = (struct ef4_nic *)context;
-       struct falcon_nic_data *nic_data = efx->nic_data;
+       struct falcon_nic_data *nic_data = from_timer(nic_data, t,
+                                                     stats_timer);
+       struct ef4_nic *efx = nic_data->efx;
 
        spin_lock(&efx->stats_lock);
 
        if (!nic_data)
                return -ENOMEM;
        efx->nic_data = nic_data;
+       nic_data->efx = efx;
 
        rc = -ENODEV;
 
        }
 
        nic_data->stats_disable_count = 1;
-       setup_timer(&nic_data->stats_timer, &falcon_stats_timer_func,
-                   (unsigned long)efx);
+       timer_setup(&nic_data->stats_timer, falcon_stats_timer_func, 0);
 
        return 0;
 
 
 /**
  * struct falcon_nic_data - Falcon NIC state
  * @pci_dev2: Secondary function of Falcon A
+ * @efx: ef4_nic pointer
  * @board: Board state and functions
  * @stats: Hardware statistics
  * @stats_disable_count: Nest count for disabling statistics fetches
  */
 struct falcon_nic_data {
        struct pci_dev *pci_dev2;
+       struct ef4_nic *efx;
        struct falcon_board board;
        u64 stats[FALCON_STAT_COUNT];
        unsigned int stats_disable_count;
 
                ef4_nic_notify_rx_desc(rx_queue);
 }
 
-void ef4_rx_slow_fill(unsigned long context)
+void ef4_rx_slow_fill(struct timer_list *t)
 {
-       struct ef4_rx_queue *rx_queue = (struct ef4_rx_queue *)context;
+       struct ef4_rx_queue *rx_queue = from_timer(rx_queue, t, slow_fill);
 
        /* Post an event to cause NAPI to run and refill the queue */
        ef4_nic_generate_fill_event(rx_queue);
 
        /* followed by request/response buffer */
 };
 
-static void efx_mcdi_timeout_async(unsigned long context);
+static void efx_mcdi_timeout_async(struct timer_list *t);
 static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating,
                               bool *was_attached_out);
 static bool efx_mcdi_poll_once(struct efx_nic *efx);
        mcdi->mode = MCDI_MODE_POLL;
        spin_lock_init(&mcdi->async_lock);
        INIT_LIST_HEAD(&mcdi->async_list);
-       setup_timer(&mcdi->async_timer, efx_mcdi_timeout_async,
-                   (unsigned long)mcdi);
+       timer_setup(&mcdi->async_timer, efx_mcdi_timeout_async, 0);
 
        (void) efx_mcdi_poll_reboot(efx);
        mcdi->new_epoch = true;
        }
 }
 
-static void efx_mcdi_timeout_async(unsigned long context)
+static void efx_mcdi_timeout_async(struct timer_list *t)
 {
-       struct efx_mcdi_iface *mcdi = (struct efx_mcdi_iface *)context;
+       struct efx_mcdi_iface *mcdi = from_timer(mcdi, t, async_timer);
 
        efx_mcdi_complete_async(mcdi, true);
 }
 
                efx_nic_notify_rx_desc(rx_queue);
 }
 
-void efx_rx_slow_fill(unsigned long context)
+void efx_rx_slow_fill(struct timer_list *t)
 {
-       struct efx_rx_queue *rx_queue = (struct efx_rx_queue *)context;
+       struct efx_rx_queue *rx_queue = from_timer(rx_queue, t, slow_fill);
 
        /* Post an event to cause NAPI to run and refill the queue */
        efx_nic_generate_fill_event(rx_queue);