pr_debug("%s: %s dbusytimer running\n", isac->name, __func__);
                del_timer(&isac->dch.timer);
        }
-       init_timer(&isac->dch.timer);
        isac->dch.timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
        add_timer(&isac->dch.timer);
        if (isac->dch.debug & DEBUG_HW_DFIFO) {
 }
 
 static void
-dbusy_timer_handler(struct isac_hw *isac)
+dbusy_timer_handler(struct timer_list *t)
 {
+       struct isac_hw *isac = from_timer(isac, t, dch.timer);
        int rbch, star;
        u_long flags;
 
        }
        isac->mon_tx = NULL;
        isac->mon_rx = NULL;
-       setup_timer(&isac->dch.timer, (void *)dbusy_timer_handler,
-                   (long)isac);
+       timer_setup(&isac->dch.timer, dbusy_timer_handler, 0);
        isac->mocr = 0xaa;
        if (isac->type & IPAC_TYPE_ISACX) {
                /* Disable all IRQ */
 
                pr_debug("%s: fill_Dfifo dbusytimer running\n", card->name);
                del_timer(&dch->timer);
        }
-       init_timer(&dch->timer);
        dch->timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
        add_timer(&dch->timer);
        if (debug & DEBUG_HW_DFIFO) {
 }
 
 static void
-dbusy_timer_handler(struct dchannel *dch)
+dbusy_timer_handler(struct timer_list *t)
 {
+       struct dchannel *dch = from_timer(dch, t, timer);
        struct w6692_hw *card = dch->hw;
        int             rbch, star;
        u_long          flags;
 {
        u8      val;
 
-       setup_timer(&card->dch.timer, (void *)dbusy_timer_handler,
-                   (u_long)&card->dch);
+       timer_setup(&card->dch.timer, dbusy_timer_handler, 0);
        w6692_mode(&card->bc[0], ISDN_P_NONE);
        w6692_mode(&card->bc[1], ISDN_P_NONE);
        WriteW6692(card, W_D_CTL, 0x00);
 
 
 extern int dsp_tone(struct dsp *dsp, int tone);
 extern void dsp_tone_copy(struct dsp *dsp, u8 *data, int len);
-extern void dsp_tone_timeout(void *arg);
+extern void dsp_tone_timeout(struct timer_list *t);
 
 extern void dsp_bf_encrypt(struct dsp *dsp, u8 *data, int len);
 extern void dsp_bf_decrypt(struct dsp *dsp, u8 *data, int len);
 
        ndsp->pcm_bank_tx = -1;
        ndsp->hfc_conf = -1; /* current conference number */
        /* set tone timer */
-       setup_timer(&ndsp->tone.tl, (void *)dsp_tone_timeout, (long)ndsp);
+       timer_setup(&ndsp->tone.tl, dsp_tone_timeout, 0);
 
        if (dtmfthreshold < 20 || dtmfthreshold > 500)
                dtmfthreshold = 200;
        }
 
        /* set sample timer */
-       dsp_spl_tl.function = (void *)dsp_cmx_send;
-       dsp_spl_tl.data = 0;
-       init_timer(&dsp_spl_tl);
+       timer_setup(&dsp_spl_tl, (void *)dsp_cmx_send, 0);
        dsp_spl_tl.expires = jiffies + dsp_tics;
        dsp_spl_jiffies = dsp_spl_tl.expires;
        add_timer(&dsp_spl_tl);
 
  * timer expires *
  *****************/
 void
-dsp_tone_timeout(void *arg)
+dsp_tone_timeout(struct timer_list *t)
 {
-       struct dsp *dsp = arg;
+       struct dsp *dsp = from_timer(dsp, t, tone.tl);
        struct dsp_tone *tone = &dsp->tone;
        struct pattern *pat = (struct pattern *)tone->pattern;
        int index = tone->index;
        else
                dsp_tone_hw_message(dsp, pat->data[index], *(pat->siz[index]));
        /* set timer */
-       init_timer(&tone->tl);
        tone->tl.expires = jiffies + (pat->seq[index] * HZ) / 8000;
        add_timer(&tone->tl);
 }
                /* set timer */
                if (timer_pending(&tonet->tl))
                        del_timer(&tonet->tl);
-               init_timer(&tonet->tl);
                tonet->tl.expires = jiffies + (pat->seq[0] * HZ) / 8000;
                add_timer(&tonet->tl);
        } else {
 
 EXPORT_SYMBOL(mISDN_FsmChangeState);
 
 static void
-FsmExpireTimer(struct FsmTimer *ft)
+FsmExpireTimer(struct timer_list *t)
 {
+       struct FsmTimer *ft = from_timer(ft, t, tl);
 #if FSM_TIMER_DEBUG
        if (ft->fi->debug)
                ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft);
        if (ft->fi->debug)
                ft->fi->printdebug(ft->fi, "mISDN_FsmInitTimer %lx", (long) ft);
 #endif
-       setup_timer(&ft->tl, (void *)FsmExpireTimer, (long)ft);
+       timer_setup(&ft->tl, FsmExpireTimer, 0);
 }
 EXPORT_SYMBOL(mISDN_FsmInitTimer);
 
                }
                return -1;
        }
-       init_timer(&ft->tl);
        ft->event = event;
        ft->arg = arg;
        ft->tl.expires = jiffies + (millisec * HZ) / 1000;
 
        if (timer_pending(&ft->tl))
                del_timer(&ft->tl);
-       init_timer(&ft->tl);
        ft->event = event;
        ft->arg = arg;
        ft->tl.expires = jiffies + (millisec * HZ) / 1000;
 
  * timer stuff
  */
 static void
-l1oip_keepalive(void *data)
+l1oip_keepalive(struct timer_list *t)
 {
-       struct l1oip *hc = (struct l1oip *)data;
+       struct l1oip *hc = from_timer(hc, t, keep_tl);
 
        schedule_work(&hc->workq);
 }
 
 static void
-l1oip_timeout(void *data)
+l1oip_timeout(struct timer_list *t)
 {
-       struct l1oip                    *hc = (struct l1oip *)data;
+       struct l1oip                    *hc = from_timer(hc, t,
+                                                                 timeout_tl);
        struct dchannel         *dch = hc->chan[hc->d_idx].dch;
 
        if (debug & DEBUG_L1OIP_MSG)
        if (ret)
                return ret;
 
-       hc->keep_tl.function = (void *)l1oip_keepalive;
-       hc->keep_tl.data = (ulong)hc;
-       init_timer(&hc->keep_tl);
+       timer_setup(&hc->keep_tl, l1oip_keepalive, 0);
        hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */
        add_timer(&hc->keep_tl);
 
-       setup_timer(&hc->timeout_tl, (void *)l1oip_timeout, (ulong)hc);
+       timer_setup(&hc->timeout_tl, l1oip_timeout, 0);
        hc->timeout_on = 0; /* state that we have timer off */
 
        return 0;
 
 }
 
 static void
-dev_expire_timer(unsigned long data)
+dev_expire_timer(struct timer_list *t)
 {
-       struct mISDNtimer *timer = (void *)data;
+       struct mISDNtimer *timer = from_timer(timer, t, tl);
        u_long                  flags;
 
        spin_lock_irqsave(&timer->dev->lock, flags);
                if (!timer)
                        return -ENOMEM;
                timer->dev = dev;
-               setup_timer(&timer->tl, dev_expire_timer, (long)timer);
+               timer_setup(&timer->tl, dev_expire_timer, 0);
                spin_lock_irq(&dev->lock);
                id = timer->id = dev->next_id++;
                if (dev->next_id < 0)