#endif
 }
 
-static void cas_link_timer(unsigned long data)
+static void cas_link_timer(struct timer_list *t)
 {
-       struct cas *cp = (struct cas *) data;
+       struct cas *cp = from_timer(cp, t, link_timer);
        int mask, pending = 0, reset = 0;
        unsigned long flags;
 
        spin_lock_init(&cp->stat_lock[N_TX_RINGS]);
        mutex_init(&cp->pm_mutex);
 
-       setup_timer(&cp->link_timer, cas_link_timer, (unsigned long)cp);
+       timer_setup(&cp->link_timer, cas_link_timer, 0);
+
 #if 1
        /* Just in case the implementation of atomic operations
         * change so that an explicit initialization is necessary.
 
        list_add_rcu(&port->list, &vp->port_list);
        spin_unlock_irqrestore(&vp->lock, flags);
 
-       setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common,
-                   (unsigned long)port);
+       timer_setup(&port->clean_timer, sunvnet_clean_timer_expire_common, 0);
 
        err = register_netdev(dev);
        if (err) {
 
        return err;
 }
 
-static void niu_timer(unsigned long __opaque)
+static void niu_timer(struct timer_list *t)
 {
-       struct niu *np = (struct niu *) __opaque;
+       struct niu *np = from_timer(np, t, timer);
        unsigned long off;
        int err, link_up;
 
 
        err = niu_init_hw(np);
        if (!err) {
-               setup_timer(&np->timer, niu_timer, (unsigned long)np);
+               timer_setup(&np->timer, niu_timer, 0);
                np->timer.expires = jiffies + HZ;
 
                err = niu_enable_interrupts(np, 1);
 
        err = niu_init_hw(np);
        if (!err) {
-               init_timer(&np->timer);
+               timer_setup(&np->timer, niu_timer, 0);
                np->timer.expires = jiffies + HZ;
-               np->timer.data = (unsigned long) np;
-               np->timer.function = niu_timer;
 
                err = niu_enable_interrupts(np, 1);
                if (err)
 
        return -1;
 }
 
-static void bigmac_timer(unsigned long data)
+static void bigmac_timer(struct timer_list *t)
 {
-       struct bigmac *bp = (struct bigmac *) data;
+       struct bigmac *bp = from_timer(bp, t, bigmac_timer);
        void __iomem *tregs = bp->tregs;
        int restart_timer = 0;
 
        bp->timer_state = ltrywait;
        bp->timer_ticks = 0;
        bp->bigmac_timer.expires = jiffies + (12 * HZ) / 10;
-       bp->bigmac_timer.data = (unsigned long) bp;
-       bp->bigmac_timer.function = bigmac_timer;
        add_timer(&bp->bigmac_timer);
 }
 
                printk(KERN_ERR "BIGMAC: Can't order irq %d to go.\n", dev->irq);
                return ret;
        }
-       init_timer(&bp->bigmac_timer);
+       timer_setup(&bp->bigmac_timer, bigmac_timer, 0);
        ret = bigmac_init_hw(bp, 0);
        if (ret)
                free_irq(dev->irq, bp);
                                              "board-version", 1);
 
        /* Init auto-negotiation timer state. */
-       init_timer(&bp->bigmac_timer);
+       timer_setup(&bp->bigmac_timer, bigmac_timer, 0);
        bp->timer_state = asleep;
        bp->timer_ticks = 0;
 
 
        }
 }
 
-static void gem_link_timer(unsigned long data)
+static void gem_link_timer(struct timer_list *t)
 {
-       struct gem *gp = (struct gem *) data;
+       struct gem *gp = from_timer(gp, t, link_timer);
        struct net_device *dev = gp->dev;
        int restart_aneg = 0;
 
 
        gp->msg_enable = DEFAULT_MSG;
 
-       setup_timer(&gp->link_timer, gem_link_timer, (unsigned long)gp);
+       timer_setup(&gp->link_timer, gem_link_timer, 0);
 
        INIT_WORK(&gp->reset_task, gem_reset_task);
 
 
        return ret;
 }
 
-static void happy_meal_timer(unsigned long data)
+static void happy_meal_timer(struct timer_list *t)
 {
-       struct happy_meal *hp = (struct happy_meal *) data;
+       struct happy_meal *hp = from_timer(hp, t, happy_timer);
        void __iomem *tregs = hp->tcvregs;
        int restart_timer = 0;
 
 
        hp->timer_ticks = 0;
        hp->happy_timer.expires = jiffies + (12 * HZ)/10;  /* 1.2 sec. */
-       hp->happy_timer.data = (unsigned long) hp;
-       hp->happy_timer.function = happy_meal_timer;
        add_timer(&hp->happy_timer);
 }
 
        hp->timer_state = asleep;
        hp->timer_ticks = 0;
 
-       init_timer(&hp->happy_timer);
+       timer_setup(&hp->happy_timer, happy_meal_timer, 0);
 
        hp->dev = dev;
        dev->netdev_ops = &hme_netdev_ops;
        hp->timer_state = asleep;
        hp->timer_ticks = 0;
 
-       init_timer(&hp->happy_timer);
+       timer_setup(&hp->happy_timer, happy_meal_timer, 0);
 
        hp->irq = pdev->irq;
        hp->dev = dev;
 
        pr_info("%s: PORT ( remote-mac %pM%s )\n",
                vp->dev->name, port->raddr, switch_port ? " switch-port" : "");
 
-       setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common,
-                   (unsigned long)port);
+       timer_setup(&port->clean_timer, sunvnet_clean_timer_expire_common, 0);
 
        napi_enable(&port->napi);
        vio_port_up(&port->vio);
 
        }
 }
 
-void sunvnet_clean_timer_expire_common(unsigned long port0)
+void sunvnet_clean_timer_expire_common(struct timer_list *t)
 {
-       struct vnet_port *port = (struct vnet_port *)port0;
+       struct vnet_port *port = from_timer(port, t, clean_timer);
        struct sk_buff *freeskbs;
        unsigned pending;
 
 
        ((__port)->vsw ? (__port)->dev : (__port)->vp->dev)
 
 /* Common funcs */
-void sunvnet_clean_timer_expire_common(unsigned long port0);
+void sunvnet_clean_timer_expire_common(struct timer_list *t);
 int sunvnet_open_common(struct net_device *dev);
 int sunvnet_close_common(struct net_device *dev);
 void sunvnet_set_rx_mode_common(struct net_device *dev, struct vnet *vp);