struct irq_work work;
 };
 
-static void timer_i915_sw_fence_wake(unsigned long data)
+static void timer_i915_sw_fence_wake(struct timer_list *t)
 {
-       struct i915_sw_dma_fence_cb *cb = (struct i915_sw_dma_fence_cb *)data;
+       struct i915_sw_dma_fence_cb *cb = from_timer(cb, t, timer);
        struct i915_sw_fence *fence;
 
        fence = xchg(&cb->fence, NULL);
        i915_sw_fence_await(fence);
 
        cb->dma = NULL;
-       __setup_timer(&cb->timer,
-                     timer_i915_sw_fence_wake, (unsigned long)cb,
-                     TIMER_IRQSAFE);
+       timer_setup(&cb->timer, timer_i915_sw_fence_wake, TIMER_IRQSAFE);
        init_irq_work(&cb->work, irq_i915_sw_fence_work);
        if (timeout) {
                cb->dma = dma_fence_get(dma);
 
        set_bit(engine->id, &engine->i915->gpu_error.missed_irq_rings);
 }
 
-static void intel_breadcrumbs_hangcheck(unsigned long data)
+static void intel_breadcrumbs_hangcheck(struct timer_list *t)
 {
-       struct intel_engine_cs *engine = (struct intel_engine_cs *)data;
+       struct intel_engine_cs *engine = from_timer(engine, t,
+                                                   breadcrumbs.hangcheck);
        struct intel_breadcrumbs *b = &engine->breadcrumbs;
 
        if (!b->irq_armed)
        }
 }
 
-static void intel_breadcrumbs_fake_irq(unsigned long data)
+static void intel_breadcrumbs_fake_irq(struct timer_list *t)
 {
-       struct intel_engine_cs *engine = (struct intel_engine_cs *)data;
+       struct intel_engine_cs *engine = from_timer(engine, t,
+                                                   breadcrumbs.fake_irq);
        struct intel_breadcrumbs *b = &engine->breadcrumbs;
 
        /* The timer persists in case we cannot enable interrupts,
        spin_lock_init(&b->rb_lock);
        spin_lock_init(&b->irq_lock);
 
-       setup_timer(&b->fake_irq,
-                   intel_breadcrumbs_fake_irq,
-                   (unsigned long)engine);
-       setup_timer(&b->hangcheck,
-                   intel_breadcrumbs_hangcheck,
-                   (unsigned long)engine);
+       timer_setup(&b->fake_irq, intel_breadcrumbs_fake_irq, 0);
+       timer_setup(&b->hangcheck, intel_breadcrumbs_hangcheck, 0);
 
        /* Spawn a thread to provide a common bottom-half for all signals.
         * As this is an asynchronous interface we cannot steal the current
 
                                        link);
 }
 
-static void hw_delay_complete(unsigned long data)
+static void hw_delay_complete(struct timer_list *t)
 {
-       struct mock_engine *engine = (typeof(engine))data;
+       struct mock_engine *engine = from_timer(engine, t, hw_delay);
        struct mock_request *request;
 
        spin_lock(&engine->hw_lock);
 
        /* fake hw queue */
        spin_lock_init(&engine->hw_lock);
-       setup_timer(&engine->hw_delay,
-                   hw_delay_complete,
-                   (unsigned long)engine);
+       timer_setup(&engine->hw_delay, hw_delay_complete, 0);
        INIT_LIST_HEAD(&engine->hw_queue);
 
        return &engine->base;