Merge branch 'networking-Convert-timers-to-use-timer_setup'

Kees Cook says:

====================
networking: Convert timers to use timer_setup()

This is the current set of outstanding networking patches to perform
conversions to the new timer interface (rebased to -next). This is not
all expected conversions, but it contains everything needed in networking
to eliminate init_timer(), and all the non-standard setup_*_timer() uses.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2017-10-18 12:40:40 +01:00
commit 2af55f4607
154 changed files with 781 additions and 904 deletions

View File

@ -168,7 +168,6 @@ static int uml_net_open(struct net_device *dev)
goto out_close; goto out_close;
} }
lp->tl.data = (unsigned long) &lp->user;
netif_start_queue(dev); netif_start_queue(dev);
/* clear buffer - it can happen that the host side of the interface /* clear buffer - it can happen that the host side of the interface
@ -278,10 +277,11 @@ static const struct ethtool_ops uml_net_ethtool_ops = {
.get_ts_info = ethtool_op_get_ts_info, .get_ts_info = ethtool_op_get_ts_info,
}; };
static void uml_net_user_timer_expire(unsigned long _conn) static void uml_net_user_timer_expire(struct timer_list *t)
{ {
#ifdef undef #ifdef undef
struct connection *conn = (struct connection *)_conn; struct uml_net_private *lp = from_timer(lp, t, tl);
struct connection *conn = &lp->user;
dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn); dprintk(KERN_INFO "uml_net_user_timer_expire [%p]\n", conn);
do_connect(conn); do_connect(conn);
@ -458,9 +458,8 @@ static void eth_configure(int n, void *init, char *mac,
.add_address = transport->user->add_address, .add_address = transport->user->add_address,
.delete_address = transport->user->delete_address }); .delete_address = transport->user->delete_address });
init_timer(&lp->tl); timer_setup(&lp->tl, uml_net_user_timer_expire, 0);
spin_lock_init(&lp->lock); spin_lock_init(&lp->lock);
lp->tl.function = uml_net_user_timer_expire;
memcpy(lp->mac, dev->dev_addr, sizeof(lp->mac)); memcpy(lp->mac, dev->dev_addr, sizeof(lp->mac));
if ((transport->user->init != NULL) && if ((transport->user->init != NULL) &&

View File

@ -2073,21 +2073,19 @@ idt77252_rate_logindex(struct idt77252_dev *card, int pcr)
} }
static void static void
idt77252_est_timer(unsigned long data) idt77252_est_timer(struct timer_list *t)
{ {
struct vc_map *vc = (struct vc_map *)data; struct rate_estimator *est = from_timer(est, t, timer);
struct vc_map *vc = est->vc;
struct idt77252_dev *card = vc->card; struct idt77252_dev *card = vc->card;
struct rate_estimator *est;
unsigned long flags; unsigned long flags;
u32 rate, cps; u32 rate, cps;
u64 ncells; u64 ncells;
u8 lacr; u8 lacr;
spin_lock_irqsave(&vc->lock, flags); spin_lock_irqsave(&vc->lock, flags);
est = vc->estimator; if (!vc->estimator)
if (!est)
goto out; goto out;
ncells = est->cells; ncells = est->cells;
rate = ((u32)(ncells - est->last_cells)) << (7 - est->interval); rate = ((u32)(ncells - est->last_cells)) << (7 - est->interval);
@ -2126,10 +2124,11 @@ idt77252_init_est(struct vc_map *vc, int pcr)
est->maxcps = pcr < 0 ? -pcr : pcr; est->maxcps = pcr < 0 ? -pcr : pcr;
est->cps = est->maxcps; est->cps = est->maxcps;
est->avcps = est->cps << 5; est->avcps = est->cps << 5;
est->vc = vc;
est->interval = 2; /* XXX: make this configurable */ est->interval = 2; /* XXX: make this configurable */
est->ewma_log = 2; /* XXX: make this configurable */ est->ewma_log = 2; /* XXX: make this configurable */
setup_timer(&est->timer, idt77252_est_timer, (unsigned long)vc); timer_setup(&est->timer, idt77252_est_timer, 0);
mod_timer(&est->timer, jiffies + ((HZ / 4) << est->interval)); mod_timer(&est->timer, jiffies + ((HZ / 4) << est->interval));
return est; return est;
@ -2209,16 +2208,20 @@ static int
idt77252_init_ubr(struct idt77252_dev *card, struct vc_map *vc, idt77252_init_ubr(struct idt77252_dev *card, struct vc_map *vc,
struct atm_vcc *vcc, struct atm_qos *qos) struct atm_vcc *vcc, struct atm_qos *qos)
{ {
struct rate_estimator *est = NULL;
unsigned long flags; unsigned long flags;
int tcr; int tcr;
spin_lock_irqsave(&vc->lock, flags); spin_lock_irqsave(&vc->lock, flags);
if (vc->estimator) { if (vc->estimator) {
del_timer(&vc->estimator->timer); est = vc->estimator;
kfree(vc->estimator);
vc->estimator = NULL; vc->estimator = NULL;
} }
spin_unlock_irqrestore(&vc->lock, flags); spin_unlock_irqrestore(&vc->lock, flags);
if (est) {
del_timer_sync(&est->timer);
kfree(est);
}
tcr = atm_pcr_goal(&qos->txtp); tcr = atm_pcr_goal(&qos->txtp);
if (tcr == 0) if (tcr == 0)

View File

@ -184,6 +184,8 @@ struct aal1 {
unsigned char sequence; unsigned char sequence;
}; };
struct vc_map;
struct rate_estimator { struct rate_estimator {
struct timer_list timer; struct timer_list timer;
unsigned int interval; unsigned int interval;
@ -193,6 +195,7 @@ struct rate_estimator {
long avcps; long avcps;
u32 cps; u32 cps;
u32 maxcps; u32 maxcps;
struct vc_map *vc;
}; };
struct vc_map { struct vc_map {

View File

@ -53,7 +53,7 @@ static DEFINE_SPINLOCK(sunis_lock);
if (atomic_read(&stats->s) < 0) atomic_set(&stats->s,INT_MAX); if (atomic_read(&stats->s) < 0) atomic_set(&stats->s,INT_MAX);
static void suni_hz(unsigned long from_timer) static void suni_hz(struct timer_list *timer)
{ {
struct suni_priv *walk; struct suni_priv *walk;
struct atm_dev *dev; struct atm_dev *dev;
@ -85,7 +85,7 @@ static void suni_hz(unsigned long from_timer)
((GET(TACP_TCC) & 0xff) << 8) | ((GET(TACP_TCC) & 0xff) << 8) |
((GET(TACP_TCCM) & 7) << 16)); ((GET(TACP_TCCM) & 7) << 16));
} }
if (from_timer) mod_timer(&poll_timer,jiffies+HZ); if (timer) mod_timer(&poll_timer,jiffies+HZ);
} }
@ -322,13 +322,11 @@ static int suni_start(struct atm_dev *dev)
printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type, printk(KERN_WARNING "%s(itf %d): no signal\n",dev->type,
dev->number); dev->number);
PRIV(dev)->loop_mode = ATM_LM_NONE; PRIV(dev)->loop_mode = ATM_LM_NONE;
suni_hz(0); /* clear SUNI counters */ suni_hz(NULL); /* clear SUNI counters */
(void) fetch_stats(dev,NULL,1); /* clear kernel counters */ (void) fetch_stats(dev,NULL,1); /* clear kernel counters */
if (first) { if (first) {
init_timer(&poll_timer); timer_setup(&poll_timer, suni_hz, 0);
poll_timer.expires = jiffies+HZ; poll_timer.expires = jiffies+HZ;
poll_timer.function = suni_hz;
poll_timer.data = 1;
#if 0 #if 0
printk(KERN_DEBUG "[u] p=0x%lx,n=0x%lx\n",(unsigned long) poll_timer.list.prev, printk(KERN_DEBUG "[u] p=0x%lx,n=0x%lx\n",(unsigned long) poll_timer.list.prev,
(unsigned long) poll_timer.list.next); (unsigned long) poll_timer.list.next);

View File

@ -433,10 +433,11 @@ static void check_pending(struct bas_cardstate *ucs)
* argument: * argument:
* controller state structure * controller state structure
*/ */
static void cmd_in_timeout(unsigned long data) static void cmd_in_timeout(struct timer_list *t)
{ {
struct cardstate *cs = (struct cardstate *) data; struct bas_cardstate *ucs = from_timer(ucs, t, timer_cmd_in);
struct bas_cardstate *ucs = cs->hw.bas; struct urb *urb = ucs->urb_int_in;
struct cardstate *cs = urb->context;
int rc; int rc;
if (!ucs->rcvbuf_size) { if (!ucs->rcvbuf_size) {
@ -639,10 +640,11 @@ static void int_in_work(struct work_struct *work)
* argument: * argument:
* controller state structure * controller state structure
*/ */
static void int_in_resubmit(unsigned long data) static void int_in_resubmit(struct timer_list *t)
{ {
struct cardstate *cs = (struct cardstate *) data; struct bas_cardstate *ucs = from_timer(ucs, t, timer_int_in);
struct bas_cardstate *ucs = cs->hw.bas; struct urb *urb = ucs->urb_int_in;
struct cardstate *cs = urb->context;
int rc; int rc;
if (ucs->retry_int_in++ >= BAS_RETRY) { if (ucs->retry_int_in++ >= BAS_RETRY) {
@ -1441,10 +1443,11 @@ error:
* argument: * argument:
* controller state structure * controller state structure
*/ */
static void req_timeout(unsigned long data) static void req_timeout(struct timer_list *t)
{ {
struct cardstate *cs = (struct cardstate *) data; struct bas_cardstate *ucs = from_timer(ucs, t, timer_ctrl);
struct bas_cardstate *ucs = cs->hw.bas; struct urb *urb = ucs->urb_int_in;
struct cardstate *cs = urb->context;
int pending; int pending;
unsigned long flags; unsigned long flags;
@ -1837,10 +1840,11 @@ static void write_command_callback(struct urb *urb)
* argument: * argument:
* controller state structure * controller state structure
*/ */
static void atrdy_timeout(unsigned long data) static void atrdy_timeout(struct timer_list *t)
{ {
struct cardstate *cs = (struct cardstate *) data; struct bas_cardstate *ucs = from_timer(ucs, t, timer_atrdy);
struct bas_cardstate *ucs = cs->hw.bas; struct urb *urb = ucs->urb_int_in;
struct cardstate *cs = urb->context;
dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n"); dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n");
@ -2200,7 +2204,7 @@ static int gigaset_initcshw(struct cardstate *cs)
{ {
struct bas_cardstate *ucs; struct bas_cardstate *ucs;
cs->hw.bas = ucs = kmalloc(sizeof *ucs, GFP_KERNEL); cs->hw.bas = ucs = kzalloc(sizeof(*ucs), GFP_KERNEL);
if (!ucs) { if (!ucs) {
pr_err("out of memory\n"); pr_err("out of memory\n");
return -ENOMEM; return -ENOMEM;
@ -2212,19 +2216,11 @@ static int gigaset_initcshw(struct cardstate *cs)
return -ENOMEM; return -ENOMEM;
} }
ucs->urb_cmd_in = NULL;
ucs->urb_cmd_out = NULL;
ucs->rcvbuf = NULL;
ucs->rcvbuf_size = 0;
spin_lock_init(&ucs->lock); spin_lock_init(&ucs->lock);
ucs->pending = 0; timer_setup(&ucs->timer_ctrl, req_timeout, 0);
timer_setup(&ucs->timer_atrdy, atrdy_timeout, 0);
ucs->basstate = 0; timer_setup(&ucs->timer_cmd_in, cmd_in_timeout, 0);
setup_timer(&ucs->timer_ctrl, req_timeout, (unsigned long) cs); timer_setup(&ucs->timer_int_in, int_in_resubmit, 0);
setup_timer(&ucs->timer_atrdy, atrdy_timeout, (unsigned long) cs);
setup_timer(&ucs->timer_cmd_in, cmd_in_timeout, (unsigned long) cs);
setup_timer(&ucs->timer_int_in, int_in_resubmit, (unsigned long) cs);
init_waitqueue_head(&ucs->waitqueue); init_waitqueue_head(&ucs->waitqueue);
INIT_WORK(&ucs->int_in_wq, int_in_work); INIT_WORK(&ucs->int_in_wq, int_in_work);

View File

@ -153,9 +153,9 @@ static int test_timeout(struct at_state_t *at_state)
return 1; return 1;
} }
static void timer_tick(unsigned long data) static void timer_tick(struct timer_list *t)
{ {
struct cardstate *cs = (struct cardstate *) data; struct cardstate *cs = from_timer(cs, t, timer);
unsigned long flags; unsigned long flags;
unsigned channel; unsigned channel;
struct at_state_t *at_state; struct at_state_t *at_state;
@ -687,7 +687,7 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
cs->ignoreframes = ignoreframes; cs->ignoreframes = ignoreframes;
INIT_LIST_HEAD(&cs->temp_at_states); INIT_LIST_HEAD(&cs->temp_at_states);
cs->running = 0; cs->running = 0;
init_timer(&cs->timer); /* clear next & prev */ timer_setup(&cs->timer, timer_tick, 0);
spin_lock_init(&cs->ev_lock); spin_lock_init(&cs->ev_lock);
cs->ev_tail = 0; cs->ev_tail = 0;
cs->ev_head = 0; cs->ev_head = 0;
@ -768,7 +768,6 @@ struct cardstate *gigaset_initcs(struct gigaset_driver *drv, int channels,
spin_lock_irqsave(&cs->lock, flags); spin_lock_irqsave(&cs->lock, flags);
cs->running = 1; cs->running = 1;
spin_unlock_irqrestore(&cs->lock, flags); spin_unlock_irqrestore(&cs->lock, flags);
setup_timer(&cs->timer, timer_tick, (unsigned long) cs);
cs->timer.expires = jiffies + msecs_to_jiffies(GIG_TICK); cs->timer.expires = jiffies + msecs_to_jiffies(GIG_TICK);
add_timer(&cs->timer); add_timer(&cs->timer);

View File

@ -172,7 +172,6 @@ isac_fill_fifo(struct isac_hw *isac)
pr_debug("%s: %s dbusytimer running\n", isac->name, __func__); pr_debug("%s: %s dbusytimer running\n", isac->name, __func__);
del_timer(&isac->dch.timer); del_timer(&isac->dch.timer);
} }
init_timer(&isac->dch.timer);
isac->dch.timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000); isac->dch.timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
add_timer(&isac->dch.timer); add_timer(&isac->dch.timer);
if (isac->dch.debug & DEBUG_HW_DFIFO) { if (isac->dch.debug & DEBUG_HW_DFIFO) {
@ -727,8 +726,9 @@ isac_release(struct isac_hw *isac)
} }
static void 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; int rbch, star;
u_long flags; u_long flags;
@ -796,8 +796,7 @@ isac_init(struct isac_hw *isac)
} }
isac->mon_tx = NULL; isac->mon_tx = NULL;
isac->mon_rx = NULL; isac->mon_rx = NULL;
setup_timer(&isac->dch.timer, (void *)dbusy_timer_handler, timer_setup(&isac->dch.timer, dbusy_timer_handler, 0);
(long)isac);
isac->mocr = 0xaa; isac->mocr = 0xaa;
if (isac->type & IPAC_TYPE_ISACX) { if (isac->type & IPAC_TYPE_ISACX) {
/* Disable all IRQ */ /* Disable all IRQ */

View File

@ -311,7 +311,6 @@ W6692_fill_Dfifo(struct w6692_hw *card)
pr_debug("%s: fill_Dfifo dbusytimer running\n", card->name); pr_debug("%s: fill_Dfifo dbusytimer running\n", card->name);
del_timer(&dch->timer); del_timer(&dch->timer);
} }
init_timer(&dch->timer);
dch->timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000); dch->timer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
add_timer(&dch->timer); add_timer(&dch->timer);
if (debug & DEBUG_HW_DFIFO) { if (debug & DEBUG_HW_DFIFO) {
@ -819,8 +818,9 @@ w6692_irq(int intno, void *dev_id)
} }
static void 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; struct w6692_hw *card = dch->hw;
int rbch, star; int rbch, star;
u_long flags; u_long flags;
@ -852,8 +852,7 @@ static void initW6692(struct w6692_hw *card)
{ {
u8 val; u8 val;
setup_timer(&card->dch.timer, (void *)dbusy_timer_handler, timer_setup(&card->dch.timer, dbusy_timer_handler, 0);
(u_long)&card->dch);
w6692_mode(&card->bc[0], ISDN_P_NONE); w6692_mode(&card->bc[0], ISDN_P_NONE);
w6692_mode(&card->bc[1], ISDN_P_NONE); w6692_mode(&card->bc[1], ISDN_P_NONE);
WriteW6692(card, W_D_CTL, 0x00); WriteW6692(card, W_D_CTL, 0x00);

View File

@ -398,7 +398,6 @@ Amd7930_fill_Dfifo(struct IsdnCardState *cs)
debugl1(cs, "Amd7930: fill_Dfifo dbusytimer running"); debugl1(cs, "Amd7930: fill_Dfifo dbusytimer running");
del_timer(&cs->dbusytimer); del_timer(&cs->dbusytimer);
} }
init_timer(&cs->dbusytimer);
cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000); cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
add_timer(&cs->dbusytimer); add_timer(&cs->dbusytimer);
@ -686,8 +685,9 @@ DC_Close_Amd7930(struct IsdnCardState *cs) {
static void static void
dbusy_timer_handler(struct IsdnCardState *cs) dbusy_timer_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, dbusytimer);
u_long flags; u_long flags;
struct PStack *stptr; struct PStack *stptr;
WORD dtcr, der; WORD dtcr, der;
@ -790,5 +790,5 @@ void Amd7930_init(struct IsdnCardState *cs)
void setup_Amd7930(struct IsdnCardState *cs) void setup_Amd7930(struct IsdnCardState *cs)
{ {
INIT_WORK(&cs->tqueue, Amd7930_bh); INIT_WORK(&cs->tqueue, Amd7930_bh);
setup_timer(&cs->dbusytimer, (void *)dbusy_timer_handler, (long)cs); timer_setup(&cs->dbusytimer, dbusy_timer_handler, 0);
} }

View File

@ -23,7 +23,6 @@ add_arcofi_timer(struct IsdnCardState *cs) {
if (test_and_set_bit(FLG_ARCOFI_TIMER, &cs->HW_Flags)) { if (test_and_set_bit(FLG_ARCOFI_TIMER, &cs->HW_Flags)) {
del_timer(&cs->dc.isac.arcofitimer); del_timer(&cs->dc.isac.arcofitimer);
} }
init_timer(&cs->dc.isac.arcofitimer);
cs->dc.isac.arcofitimer.expires = jiffies + ((ARCOFI_TIMER_VALUE * HZ) / 1000); cs->dc.isac.arcofitimer.expires = jiffies + ((ARCOFI_TIMER_VALUE * HZ) / 1000);
add_timer(&cs->dc.isac.arcofitimer); add_timer(&cs->dc.isac.arcofitimer);
} }
@ -112,7 +111,8 @@ arcofi_fsm(struct IsdnCardState *cs, int event, void *data) {
} }
static void static void
arcofi_timer(struct IsdnCardState *cs) { arcofi_timer(struct timer_list *t) {
struct IsdnCardState *cs = from_timer(cs, t, dc.isac.arcofitimer);
arcofi_fsm(cs, ARCOFI_TIMEOUT, NULL); arcofi_fsm(cs, ARCOFI_TIMEOUT, NULL);
} }
@ -125,7 +125,7 @@ clear_arcofi(struct IsdnCardState *cs) {
void void
init_arcofi(struct IsdnCardState *cs) { init_arcofi(struct IsdnCardState *cs) {
setup_timer(&cs->dc.isac.arcofitimer, (void *)arcofi_timer, (long)cs); timer_setup(&cs->dc.isac.arcofitimer, arcofi_timer, 0);
init_waitqueue_head(&cs->dc.isac.arcofi_wait); init_waitqueue_head(&cs->dc.isac.arcofi_wait);
test_and_set_bit(HW_ARCOFI, &cs->HW_Flags); test_and_set_bit(HW_ARCOFI, &cs->HW_Flags);
} }

View File

@ -798,8 +798,9 @@ reset_diva(struct IsdnCardState *cs)
#define DIVA_ASSIGN 1 #define DIVA_ASSIGN 1
static void static void
diva_led_handler(struct IsdnCardState *cs) diva_led_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.diva.tl);
int blink = 0; int blink = 0;
if ((cs->subtyp == DIVA_IPAC_ISA) || if ((cs->subtyp == DIVA_IPAC_ISA) ||
@ -828,7 +829,6 @@ diva_led_handler(struct IsdnCardState *cs)
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg); byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
if (blink) { if (blink) {
init_timer(&cs->hw.diva.tl);
cs->hw.diva.tl.expires = jiffies + ((blink * HZ) / 1000); cs->hw.diva.tl.expires = jiffies + ((blink * HZ) / 1000);
add_timer(&cs->hw.diva.tl); add_timer(&cs->hw.diva.tl);
} }
@ -900,7 +900,7 @@ Diva_card_msg(struct IsdnCardState *cs, int mt, void *arg)
(cs->subtyp != DIVA_IPAC_PCI) && (cs->subtyp != DIVA_IPAC_PCI) &&
(cs->subtyp != DIVA_IPACX_PCI)) { (cs->subtyp != DIVA_IPACX_PCI)) {
spin_lock_irqsave(&cs->lock, flags); spin_lock_irqsave(&cs->lock, flags);
diva_led_handler(cs); diva_led_handler(&cs->hw.diva.tl);
spin_unlock_irqrestore(&cs->lock, flags); spin_unlock_irqrestore(&cs->lock, flags);
} }
return (0); return (0);
@ -978,8 +978,7 @@ static int setup_diva_common(struct IsdnCardState *cs)
printk(KERN_INFO "Diva: IPACX Design Id: %x\n", printk(KERN_INFO "Diva: IPACX Design Id: %x\n",
MemReadISAC_IPACX(cs, IPACX_ID) & 0x3F); MemReadISAC_IPACX(cs, IPACX_ID) & 0x3F);
} else { /* DIVA 2.0 */ } else { /* DIVA 2.0 */
setup_timer(&cs->hw.diva.tl, (void *)diva_led_handler, timer_setup(&cs->hw.diva.tl, diva_led_handler, 0);
(long)cs);
cs->readisac = &ReadISAC; cs->readisac = &ReadISAC;
cs->writeisac = &WriteISAC; cs->writeisac = &WriteISAC;
cs->readisacfifo = &ReadISACfifo; cs->readisacfifo = &ReadISACfifo;

View File

@ -606,8 +606,9 @@ check_arcofi(struct IsdnCardState *cs)
#endif /* ARCOFI_USE */ #endif /* ARCOFI_USE */
static void static void
elsa_led_handler(struct IsdnCardState *cs) elsa_led_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.elsa.tl);
int blink = 0; int blink = 0;
if (cs->subtyp == ELSA_PCMCIA || cs->subtyp == ELSA_PCMCIA_IPAC) if (cs->subtyp == ELSA_PCMCIA || cs->subtyp == ELSA_PCMCIA_IPAC)
@ -640,7 +641,6 @@ elsa_led_handler(struct IsdnCardState *cs)
} else } else
byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg); byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
if (blink) { if (blink) {
init_timer(&cs->hw.elsa.tl);
cs->hw.elsa.tl.expires = jiffies + ((blink * HZ) / 1000); cs->hw.elsa.tl.expires = jiffies + ((blink * HZ) / 1000);
add_timer(&cs->hw.elsa.tl); add_timer(&cs->hw.elsa.tl);
} }
@ -715,7 +715,7 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
init_modem(cs); init_modem(cs);
} }
#endif #endif
elsa_led_handler(cs); elsa_led_handler(&cs->hw.elsa.tl);
return (ret); return (ret);
case (MDL_REMOVE | REQUEST): case (MDL_REMOVE | REQUEST):
cs->hw.elsa.status &= 0; cs->hw.elsa.status &= 0;
@ -767,7 +767,7 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
else else
cs->hw.elsa.status &= ~ELSA_BAD_PWR; cs->hw.elsa.status &= ~ELSA_BAD_PWR;
} }
elsa_led_handler(cs); elsa_led_handler(&cs->hw.elsa.tl);
return (ret); return (ret);
} }
@ -1147,7 +1147,7 @@ static int setup_elsa_common(struct IsdnCard *card)
init_arcofi(cs); init_arcofi(cs);
#endif #endif
setup_isac(cs); setup_isac(cs);
setup_timer(&cs->hw.elsa.tl, (void *)elsa_led_handler, (long)cs); timer_setup(&cs->hw.elsa.tl, elsa_led_handler, 0);
/* Teste Timer */ /* Teste Timer */
if (cs->hw.elsa.timer) { if (cs->hw.elsa.timer) {
byteout(cs->hw.elsa.trig, 0xff); byteout(cs->hw.elsa.trig, 0xff);

View File

@ -85,8 +85,9 @@ FsmChangeState(struct FsmInst *fi, int newstate)
} }
static void static void
FsmExpireTimer(struct FsmTimer *ft) FsmExpireTimer(struct timer_list *t)
{ {
struct FsmTimer *ft = from_timer(ft, t, tl);
#if FSM_TIMER_DEBUG #if FSM_TIMER_DEBUG
if (ft->fi->debug) if (ft->fi->debug)
ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft); ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft);
@ -102,7 +103,7 @@ FsmInitTimer(struct FsmInst *fi, struct FsmTimer *ft)
if (ft->fi->debug) if (ft->fi->debug)
ft->fi->printdebug(ft->fi, "FsmInitTimer %lx", (long) ft); ft->fi->printdebug(ft->fi, "FsmInitTimer %lx", (long) ft);
#endif #endif
setup_timer(&ft->tl, (void *)FsmExpireTimer, (long)ft); timer_setup(&ft->tl, FsmExpireTimer, 0);
} }
void void
@ -131,7 +132,6 @@ FsmAddTimer(struct FsmTimer *ft,
ft->fi->printdebug(ft->fi, "FsmAddTimer already active!"); ft->fi->printdebug(ft->fi, "FsmAddTimer already active!");
return -1; return -1;
} }
init_timer(&ft->tl);
ft->event = event; ft->event = event;
ft->arg = arg; ft->arg = arg;
ft->tl.expires = jiffies + (millisec * HZ) / 1000; ft->tl.expires = jiffies + (millisec * HZ) / 1000;
@ -152,7 +152,6 @@ FsmRestartTimer(struct FsmTimer *ft,
if (timer_pending(&ft->tl)) if (timer_pending(&ft->tl))
del_timer(&ft->tl); del_timer(&ft->tl);
init_timer(&ft->tl);
ft->event = event; ft->event = event;
ft->arg = arg; ft->arg = arg;
ft->tl.expires = jiffies + (millisec * HZ) / 1000; ft->tl.expires = jiffies + (millisec * HZ) / 1000;

View File

@ -591,8 +591,9 @@ bch_l2l1(struct hisax_if *ifc, int pr, void *arg)
/* layer 1 timer function */ /* layer 1 timer function */
/**************************/ /**************************/
static void static void
hfc_l1_timer(struct hfc4s8s_l1 *l1) hfc_l1_timer(struct timer_list *t)
{ {
struct hfc4s8s_l1 *l1 = from_timer(l1, t, l1_timer);
u_long flags; u_long flags;
if (!l1->enabled) if (!l1->enabled)
@ -1396,8 +1397,7 @@ setup_instance(hfc4s8s_hw *hw)
l1p = hw->l1 + i; l1p = hw->l1 + i;
spin_lock_init(&l1p->lock); spin_lock_init(&l1p->lock);
l1p->hw = hw; l1p->hw = hw;
setup_timer(&l1p->l1_timer, (void *)hfc_l1_timer, timer_setup(&l1p->l1_timer, hfc_l1_timer, 0);
(long)(l1p));
l1p->st_num = i; l1p->st_num = i;
skb_queue_head_init(&l1p->d_tx_queue); skb_queue_head_init(&l1p->d_tx_queue);
l1p->d_if.ifc.priv = hw->l1 + i; l1p->d_if.ifc.priv = hw->l1 + i;

View File

@ -1014,7 +1014,7 @@ setstack_hfcd(struct PStack *st, struct IsdnCardState *cs)
} }
static void static void
hfc_dbusy_timer(struct IsdnCardState *cs) hfc_dbusy_timer(struct timer_list *t)
{ {
} }
@ -1073,6 +1073,6 @@ set_cs_func(struct IsdnCardState *cs)
cs->writeisacfifo = &dummyf; cs->writeisacfifo = &dummyf;
cs->BC_Read_Reg = &ReadReg; cs->BC_Read_Reg = &ReadReg;
cs->BC_Write_Reg = &WriteReg; cs->BC_Write_Reg = &WriteReg;
setup_timer(&cs->dbusytimer, (void *)hfc_dbusy_timer, (long)cs); timer_setup(&cs->dbusytimer, hfc_dbusy_timer, 0);
INIT_WORK(&cs->tqueue, hfcd_bh); INIT_WORK(&cs->tqueue, hfcd_bh);
} }

View File

@ -165,8 +165,9 @@ reset_hfcpci(struct IsdnCardState *cs)
/* Timer function called when kernel timer expires */ /* Timer function called when kernel timer expires */
/***************************************************/ /***************************************************/
static void static void
hfcpci_Timer(struct IsdnCardState *cs) hfcpci_Timer(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.hfcpci.timer);
cs->hw.hfcpci.timer.expires = jiffies + 75; cs->hw.hfcpci.timer.expires = jiffies + 75;
/* WD RESET */ /* WD RESET */
/* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcpci.ctmt | 0x80); /* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcpci.ctmt | 0x80);
@ -1095,7 +1096,7 @@ hfcpci_interrupt(int intno, void *dev_id)
/* timer callback for D-chan busy resolution. Currently no function */ /* timer callback for D-chan busy resolution. Currently no function */
/********************************************************************/ /********************************************************************/
static void static void
hfcpci_dbusy_timer(struct IsdnCardState *cs) hfcpci_dbusy_timer(struct timer_list *t)
{ {
} }
@ -1582,7 +1583,7 @@ inithfcpci(struct IsdnCardState *cs)
cs->bcs[1].BC_SetStack = setstack_2b; cs->bcs[1].BC_SetStack = setstack_2b;
cs->bcs[0].BC_Close = close_hfcpci; cs->bcs[0].BC_Close = close_hfcpci;
cs->bcs[1].BC_Close = close_hfcpci; cs->bcs[1].BC_Close = close_hfcpci;
setup_timer(&cs->dbusytimer, (void *)hfcpci_dbusy_timer, (long)cs); timer_setup(&cs->dbusytimer, hfcpci_dbusy_timer, 0);
mode_hfcpci(cs->bcs, 0, 0); mode_hfcpci(cs->bcs, 0, 0);
mode_hfcpci(cs->bcs + 1, 0, 1); mode_hfcpci(cs->bcs + 1, 0, 1);
} }
@ -1744,7 +1745,7 @@ setup_hfcpci(struct IsdnCard *card)
cs->BC_Write_Reg = NULL; cs->BC_Write_Reg = NULL;
cs->irq_func = &hfcpci_interrupt; cs->irq_func = &hfcpci_interrupt;
cs->irq_flags |= IRQF_SHARED; cs->irq_flags |= IRQF_SHARED;
setup_timer(&cs->hw.hfcpci.timer, (void *)hfcpci_Timer, (long)cs); timer_setup(&cs->hw.hfcpci.timer, hfcpci_Timer, 0);
cs->cardmsg = &hfcpci_card_msg; cs->cardmsg = &hfcpci_card_msg;
cs->auxcmd = &hfcpci_auxcmd; cs->auxcmd = &hfcpci_auxcmd;

View File

@ -418,8 +418,9 @@ reset_hfcsx(struct IsdnCardState *cs)
/* Timer function called when kernel timer expires */ /* Timer function called when kernel timer expires */
/***************************************************/ /***************************************************/
static void static void
hfcsx_Timer(struct IsdnCardState *cs) hfcsx_Timer(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.hfcsx.timer);
cs->hw.hfcsx.timer.expires = jiffies + 75; cs->hw.hfcsx.timer.expires = jiffies + 75;
/* WD RESET */ /* WD RESET */
/* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcsx.ctmt | 0x80); /* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcsx.ctmt | 0x80);
@ -860,7 +861,7 @@ hfcsx_interrupt(int intno, void *dev_id)
/* timer callback for D-chan busy resolution. Currently no function */ /* timer callback for D-chan busy resolution. Currently no function */
/********************************************************************/ /********************************************************************/
static void static void
hfcsx_dbusy_timer(struct IsdnCardState *cs) hfcsx_dbusy_timer(struct timer_list *t)
{ {
} }
@ -1495,7 +1496,7 @@ int setup_hfcsx(struct IsdnCard *card)
} else } else
return (0); /* no valid card type */ return (0); /* no valid card type */
setup_timer(&cs->dbusytimer, (void *)hfcsx_dbusy_timer, (long)cs); timer_setup(&cs->dbusytimer, hfcsx_dbusy_timer, 0);
INIT_WORK(&cs->tqueue, hfcsx_bh); INIT_WORK(&cs->tqueue, hfcsx_bh);
cs->readisac = NULL; cs->readisac = NULL;
cs->writeisac = NULL; cs->writeisac = NULL;
@ -1507,7 +1508,7 @@ int setup_hfcsx(struct IsdnCard *card)
cs->hw.hfcsx.b_fifo_size = 0; /* fifo size still unknown */ cs->hw.hfcsx.b_fifo_size = 0; /* fifo size still unknown */
cs->hw.hfcsx.cirm = ccd_sp_irqtab[cs->irq & 0xF]; /* RAM not evaluated */ cs->hw.hfcsx.cirm = ccd_sp_irqtab[cs->irq & 0xF]; /* RAM not evaluated */
setup_timer(&cs->hw.hfcsx.timer, (void *)hfcsx_Timer, (long)cs); timer_setup(&cs->hw.hfcsx.timer, hfcsx_Timer, 0);
reset_hfcsx(cs); reset_hfcsx(cs);
cs->cardmsg = &hfcsx_card_msg; cs->cardmsg = &hfcsx_card_msg;

View File

@ -343,8 +343,9 @@ handle_led(hfcusb_data *hfc, int event)
/* ISDN l1 timer T3 expires */ /* ISDN l1 timer T3 expires */
static void static void
l1_timer_expire_t3(hfcusb_data *hfc) l1_timer_expire_t3(struct timer_list *t)
{ {
hfcusb_data *hfc = from_timer(hfc, t, t3_timer);
hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION, hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION,
NULL); NULL);
@ -360,8 +361,9 @@ l1_timer_expire_t3(hfcusb_data *hfc)
/* ISDN l1 timer T4 expires */ /* ISDN l1 timer T4 expires */
static void static void
l1_timer_expire_t4(hfcusb_data *hfc) l1_timer_expire_t4(struct timer_list *t)
{ {
hfcusb_data *hfc = from_timer(hfc, t, t4_timer);
hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION, hfc->d_if.ifc.l1l2(&hfc->d_if.ifc, PH_DEACTIVATE | INDICATION,
NULL); NULL);
@ -1165,10 +1167,10 @@ hfc_usb_init(hfcusb_data *hfc)
hfc->old_led_state = 0; hfc->old_led_state = 0;
/* init the t3 timer */ /* init the t3 timer */
setup_timer(&hfc->t3_timer, (void *)l1_timer_expire_t3, (long)hfc); timer_setup(&hfc->t3_timer, l1_timer_expire_t3, 0);
/* init the t4 timer */ /* init the t4 timer */
setup_timer(&hfc->t4_timer, (void *)l1_timer_expire_t4, (long)hfc); timer_setup(&hfc->t4_timer, l1_timer_expire_t4, 0);
/* init the background machinery for control requests */ /* init the background machinery for control requests */
hfc->ctrl_read.bRequestType = 0xc0; hfc->ctrl_read.bRequestType = 0xc0;

View File

@ -41,8 +41,9 @@ hfcs_interrupt(int intno, void *dev_id)
} }
static void static void
hfcs_Timer(struct IsdnCardState *cs) hfcs_Timer(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.hfcD.timer);
cs->hw.hfcD.timer.expires = jiffies + 75; cs->hw.hfcD.timer.expires = jiffies + 75;
/* WD RESET */ /* WD RESET */
/* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcD.ctmt | 0x80); /* WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcD.ctmt | 0x80);
@ -253,7 +254,7 @@ int setup_hfcs(struct IsdnCard *card)
outb(0x57, cs->hw.hfcD.addr | 1); outb(0x57, cs->hw.hfcD.addr | 1);
} }
set_cs_func(cs); set_cs_func(cs);
setup_timer(&cs->hw.hfcD.timer, (void *)hfcs_Timer, (long)cs); timer_setup(&cs->hw.hfcD.timer, hfcs_Timer, 0);
cs->cardmsg = &hfcs_card_msg; cs->cardmsg = &hfcs_card_msg;
cs->irq_func = &hfcs_interrupt; cs->irq_func = &hfcs_interrupt;
return (1); return (1);

View File

@ -168,7 +168,6 @@ icc_fill_fifo(struct IsdnCardState *cs)
debugl1(cs, "icc_fill_fifo dbusytimer running"); debugl1(cs, "icc_fill_fifo dbusytimer running");
del_timer(&cs->dbusytimer); del_timer(&cs->dbusytimer);
} }
init_timer(&cs->dbusytimer);
cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000); cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
add_timer(&cs->dbusytimer); add_timer(&cs->dbusytimer);
if (cs->debug & L1_DEB_ISAC_FIFO) { if (cs->debug & L1_DEB_ISAC_FIFO) {
@ -580,8 +579,9 @@ DC_Close_icc(struct IsdnCardState *cs) {
} }
static void static void
dbusy_timer_handler(struct IsdnCardState *cs) dbusy_timer_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, dbusytimer);
struct PStack *stptr; struct PStack *stptr;
int rbch, star; int rbch, star;
@ -676,5 +676,5 @@ clear_pending_icc_ints(struct IsdnCardState *cs)
void setup_icc(struct IsdnCardState *cs) void setup_icc(struct IsdnCardState *cs)
{ {
INIT_WORK(&cs->tqueue, icc_bh); INIT_WORK(&cs->tqueue, icc_bh);
setup_timer(&cs->dbusytimer, (void *)dbusy_timer_handler, (long)cs); timer_setup(&cs->dbusytimer, dbusy_timer_handler, 0);
} }

View File

@ -35,7 +35,7 @@
static void ph_command(struct IsdnCardState *cs, unsigned int command); static void ph_command(struct IsdnCardState *cs, unsigned int command);
static inline void cic_int(struct IsdnCardState *cs); static inline void cic_int(struct IsdnCardState *cs);
static void dch_l2l1(struct PStack *st, int pr, void *arg); static void dch_l2l1(struct PStack *st, int pr, void *arg);
static void dbusy_timer_handler(struct IsdnCardState *cs); static void dbusy_timer_handler(struct timer_list *t);
static void dch_empty_fifo(struct IsdnCardState *cs, int count); static void dch_empty_fifo(struct IsdnCardState *cs, int count);
static void dch_fill_fifo(struct IsdnCardState *cs); static void dch_fill_fifo(struct IsdnCardState *cs);
static inline void dch_int(struct IsdnCardState *cs); static inline void dch_int(struct IsdnCardState *cs);
@ -198,8 +198,9 @@ dch_l2l1(struct PStack *st, int pr, void *arg)
//---------------------------------------------------------- //----------------------------------------------------------
//---------------------------------------------------------- //----------------------------------------------------------
static void static void
dbusy_timer_handler(struct IsdnCardState *cs) dbusy_timer_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, dbusytimer);
struct PStack *st; struct PStack *st;
int rbchd, stard; int rbchd, stard;
@ -298,7 +299,6 @@ dch_fill_fifo(struct IsdnCardState *cs)
debugl1(cs, "dch_fill_fifo dbusytimer running"); debugl1(cs, "dch_fill_fifo dbusytimer running");
del_timer(&cs->dbusytimer); del_timer(&cs->dbusytimer);
} }
init_timer(&cs->dbusytimer);
cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000); cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
add_timer(&cs->dbusytimer); add_timer(&cs->dbusytimer);
@ -424,7 +424,7 @@ dch_init(struct IsdnCardState *cs)
cs->setstack_d = dch_setstack; cs->setstack_d = dch_setstack;
setup_timer(&cs->dbusytimer, (void *)dbusy_timer_handler, (long)cs); timer_setup(&cs->dbusytimer, dbusy_timer_handler, 0);
cs->writeisac(cs, IPACX_TR_CONF0, 0x00); // clear LDD cs->writeisac(cs, IPACX_TR_CONF0, 0x00); // clear LDD
cs->writeisac(cs, IPACX_TR_CONF2, 0x00); // enable transmitter cs->writeisac(cs, IPACX_TR_CONF2, 0x00); // enable transmitter

View File

@ -171,7 +171,6 @@ isac_fill_fifo(struct IsdnCardState *cs)
debugl1(cs, "isac_fill_fifo dbusytimer running"); debugl1(cs, "isac_fill_fifo dbusytimer running");
del_timer(&cs->dbusytimer); del_timer(&cs->dbusytimer);
} }
init_timer(&cs->dbusytimer);
cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000); cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ)/1000);
add_timer(&cs->dbusytimer); add_timer(&cs->dbusytimer);
if (cs->debug & L1_DEB_ISAC_FIFO) { if (cs->debug & L1_DEB_ISAC_FIFO) {
@ -584,8 +583,9 @@ DC_Close_isac(struct IsdnCardState *cs)
} }
static void static void
dbusy_timer_handler(struct IsdnCardState *cs) dbusy_timer_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, dbusytimer);
struct PStack *stptr; struct PStack *stptr;
int rbch, star; int rbch, star;
@ -677,5 +677,5 @@ void clear_pending_isac_ints(struct IsdnCardState *cs)
void setup_isac(struct IsdnCardState *cs) void setup_isac(struct IsdnCardState *cs)
{ {
INIT_WORK(&cs->tqueue, isac_bh); INIT_WORK(&cs->tqueue, isac_bh);
setup_timer(&cs->dbusytimer, (void *)dbusy_timer_handler, (long)cs); timer_setup(&cs->dbusytimer, dbusy_timer_handler, 0);
} }

View File

@ -1267,7 +1267,8 @@ isar_int_main(struct IsdnCardState *cs)
} }
static void static void
ftimer_handler(struct BCState *bcs) { ftimer_handler(struct timer_list *t) {
struct BCState *bcs = from_timer(bcs, t, hw.isar.ftimer);
if (bcs->cs->debug) if (bcs->cs->debug)
debugl1(bcs->cs, "ftimer flags %04lx", debugl1(bcs->cs, "ftimer flags %04lx",
bcs->Flag); bcs->Flag);
@ -1902,8 +1903,6 @@ void initisar(struct IsdnCardState *cs)
cs->bcs[1].BC_SetStack = setstack_isar; cs->bcs[1].BC_SetStack = setstack_isar;
cs->bcs[0].BC_Close = close_isarstate; cs->bcs[0].BC_Close = close_isarstate;
cs->bcs[1].BC_Close = close_isarstate; cs->bcs[1].BC_Close = close_isarstate;
setup_timer(&cs->bcs[0].hw.isar.ftimer, (void *)ftimer_handler, timer_setup(&cs->bcs[0].hw.isar.ftimer, ftimer_handler, 0);
(long)&cs->bcs[0]); timer_setup(&cs->bcs[1].hw.isar.ftimer, ftimer_handler, 0);
setup_timer(&cs->bcs[1].hw.isar.ftimer, (void *)ftimer_handler,
(long)&cs->bcs[1]);
} }

View File

@ -160,8 +160,9 @@ newl3state(struct l3_process *pc, int state)
} }
static void static void
L3ExpireTimer(struct L3Timer *t) L3ExpireTimer(struct timer_list *timer)
{ {
struct L3Timer *t = from_timer(t, timer, tl);
t->pc->st->lli.l4l3(t->pc->st, t->event, t->pc); t->pc->st->lli.l4l3(t->pc->st, t->event, t->pc);
} }
@ -169,7 +170,7 @@ void
L3InitTimer(struct l3_process *pc, struct L3Timer *t) L3InitTimer(struct l3_process *pc, struct L3Timer *t)
{ {
t->pc = pc; t->pc = pc;
setup_timer(&t->tl, (void *)L3ExpireTimer, (long)t); timer_setup(&t->tl, L3ExpireTimer, 0);
} }
void void
@ -186,7 +187,6 @@ L3AddTimer(struct L3Timer *t,
printk(KERN_WARNING "L3AddTimer: timer already active!\n"); printk(KERN_WARNING "L3AddTimer: timer already active!\n");
return -1; return -1;
} }
init_timer(&t->tl);
t->event = event; t->event = event;
t->tl.expires = jiffies + (millisec * HZ) / 1000; t->tl.expires = jiffies + (millisec * HZ) / 1000;
add_timer(&t->tl); add_timer(&t->tl);

View File

@ -159,8 +159,9 @@ Start_ISAC:
} }
static void static void
SaphirWatchDog(struct IsdnCardState *cs) SaphirWatchDog(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.saphir.timer);
u_long flags; u_long flags;
spin_lock_irqsave(&cs->lock, flags); spin_lock_irqsave(&cs->lock, flags);
@ -268,9 +269,7 @@ int setup_saphir(struct IsdnCard *card)
cs->irq, cs->hw.saphir.cfg_reg); cs->irq, cs->hw.saphir.cfg_reg);
setup_isac(cs); setup_isac(cs);
cs->hw.saphir.timer.function = (void *) SaphirWatchDog; timer_setup(&cs->hw.saphir.timer, SaphirWatchDog, 0);
cs->hw.saphir.timer.data = (long) cs;
init_timer(&cs->hw.saphir.timer);
cs->hw.saphir.timer.expires = jiffies + 4 * HZ; cs->hw.saphir.timer.expires = jiffies + 4 * HZ;
add_timer(&cs->hw.saphir.timer); add_timer(&cs->hw.saphir.timer);
if (saphir_reset(cs)) { if (saphir_reset(cs)) {

View File

@ -179,8 +179,9 @@ Start_ISAC:
} }
static void static void
TeleInt_Timer(struct IsdnCardState *cs) TeleInt_Timer(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, hw.hfc.timer);
int stat = 0; int stat = 0;
u_long flags; u_long flags;
@ -278,7 +279,7 @@ int setup_TeleInt(struct IsdnCard *card)
cs->bcs[0].hw.hfc.send = NULL; cs->bcs[0].hw.hfc.send = NULL;
cs->bcs[1].hw.hfc.send = NULL; cs->bcs[1].hw.hfc.send = NULL;
cs->hw.hfc.fifosize = 7 * 1024 + 512; cs->hw.hfc.fifosize = 7 * 1024 + 512;
setup_timer(&cs->hw.hfc.timer, (void *)TeleInt_Timer, (long)cs); timer_setup(&cs->hw.hfc.timer, TeleInt_Timer, 0);
if (!request_region(cs->hw.hfc.addr, 2, "TeleInt isdn")) { if (!request_region(cs->hw.hfc.addr, 2, "TeleInt isdn")) {
printk(KERN_WARNING printk(KERN_WARNING
"HiSax: TeleInt config port %x-%x already in use\n", "HiSax: TeleInt config port %x-%x already in use\n",

View File

@ -188,7 +188,6 @@ W6692_fill_fifo(struct IsdnCardState *cs)
debugl1(cs, "W6692_fill_fifo dbusytimer running"); debugl1(cs, "W6692_fill_fifo dbusytimer running");
del_timer(&cs->dbusytimer); del_timer(&cs->dbusytimer);
} }
init_timer(&cs->dbusytimer);
cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000); cs->dbusytimer.expires = jiffies + ((DBUSY_TIMER_VALUE * HZ) / 1000);
add_timer(&cs->dbusytimer); add_timer(&cs->dbusytimer);
if (cs->debug & L1_DEB_ISAC_FIFO) { if (cs->debug & L1_DEB_ISAC_FIFO) {
@ -684,8 +683,9 @@ DC_Close_W6692(struct IsdnCardState *cs)
} }
static void static void
dbusy_timer_handler(struct IsdnCardState *cs) dbusy_timer_handler(struct timer_list *t)
{ {
struct IsdnCardState *cs = from_timer(cs, t, dbusytimer);
struct PStack *stptr; struct PStack *stptr;
int rbch, star; int rbch, star;
u_long flags; u_long flags;
@ -904,8 +904,7 @@ static void initW6692(struct IsdnCardState *cs, int part)
if (part & 1) { if (part & 1) {
cs->setstack_d = setstack_W6692; cs->setstack_d = setstack_W6692;
cs->DC_Close = DC_Close_W6692; cs->DC_Close = DC_Close_W6692;
setup_timer(&cs->dbusytimer, (void *)dbusy_timer_handler, timer_setup(&cs->dbusytimer, dbusy_timer_handler, 0);
(long)cs);
resetW6692(cs); resetW6692(cs);
ph_command(cs, W_L1CMD_RST); ph_command(cs, W_L1CMD_RST);
cs->dc.w6692.ph_state = W_L1CMD_RST; cs->dc.w6692.ph_state = W_L1CMD_RST;

View File

@ -90,9 +90,9 @@ isdnloop_bchan_send(isdnloop_card *card, int ch)
* data = pointer to card struct, set by kernel timer.data * data = pointer to card struct, set by kernel timer.data
*/ */
static void static void
isdnloop_pollbchan(unsigned long data) isdnloop_pollbchan(struct timer_list *t)
{ {
isdnloop_card *card = (isdnloop_card *) data; isdnloop_card *card = from_timer(card, t, rb_timer);
unsigned long flags; unsigned long flags;
if (card->flags & ISDNLOOP_FLAGS_B1ACTIVE) if (card->flags & ISDNLOOP_FLAGS_B1ACTIVE)
@ -305,9 +305,9 @@ isdnloop_putmsg(isdnloop_card *card, unsigned char c)
* data = pointer to card struct * data = pointer to card struct
*/ */
static void static void
isdnloop_polldchan(unsigned long data) isdnloop_polldchan(struct timer_list *t)
{ {
isdnloop_card *card = (isdnloop_card *) data; isdnloop_card *card = from_timer(card, t, st_timer);
struct sk_buff *skb; struct sk_buff *skb;
int avail; int avail;
int left; int left;
@ -373,8 +373,6 @@ isdnloop_polldchan(unsigned long data)
card->flags |= ISDNLOOP_FLAGS_RBTIMER; card->flags |= ISDNLOOP_FLAGS_RBTIMER;
spin_lock_irqsave(&card->isdnloop_lock, flags); spin_lock_irqsave(&card->isdnloop_lock, flags);
del_timer(&card->rb_timer); del_timer(&card->rb_timer);
card->rb_timer.function = isdnloop_pollbchan;
card->rb_timer.data = (unsigned long) card;
card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD; card->rb_timer.expires = jiffies + ISDNLOOP_TIMER_BCREAD;
add_timer(&card->rb_timer); add_timer(&card->rb_timer);
spin_unlock_irqrestore(&card->isdnloop_lock, flags); spin_unlock_irqrestore(&card->isdnloop_lock, flags);
@ -588,9 +586,10 @@ isdnloop_atimeout(isdnloop_card *card, int ch)
* Wrapper for isdnloop_atimeout(). * Wrapper for isdnloop_atimeout().
*/ */
static void static void
isdnloop_atimeout0(unsigned long data) isdnloop_atimeout0(struct timer_list *t)
{ {
isdnloop_card *card = (isdnloop_card *) data; isdnloop_card *card = from_timer(card, t, c_timer[0]);
isdnloop_atimeout(card, 0); isdnloop_atimeout(card, 0);
} }
@ -598,9 +597,10 @@ isdnloop_atimeout0(unsigned long data)
* Wrapper for isdnloop_atimeout(). * Wrapper for isdnloop_atimeout().
*/ */
static void static void
isdnloop_atimeout1(unsigned long data) isdnloop_atimeout1(struct timer_list *t)
{ {
isdnloop_card *card = (isdnloop_card *) data; isdnloop_card *card = from_timer(card, t, c_timer[1]);
isdnloop_atimeout(card, 1); isdnloop_atimeout(card, 1);
} }
@ -617,13 +617,9 @@ isdnloop_start_ctimer(isdnloop_card *card, int ch)
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&card->isdnloop_lock, flags); spin_lock_irqsave(&card->isdnloop_lock, flags);
init_timer(&card->c_timer[ch]); timer_setup(&card->c_timer[ch], ch ? isdnloop_atimeout1
: isdnloop_atimeout0, 0);
card->c_timer[ch].expires = jiffies + ISDNLOOP_TIMER_ALERTWAIT; card->c_timer[ch].expires = jiffies + ISDNLOOP_TIMER_ALERTWAIT;
if (ch)
card->c_timer[ch].function = isdnloop_atimeout1;
else
card->c_timer[ch].function = isdnloop_atimeout0;
card->c_timer[ch].data = (unsigned long) card;
add_timer(&card->c_timer[ch]); add_timer(&card->c_timer[ch]);
spin_unlock_irqrestore(&card->isdnloop_lock, flags); spin_unlock_irqrestore(&card->isdnloop_lock, flags);
} }
@ -1113,10 +1109,9 @@ isdnloop_start(isdnloop_card *card, isdnloop_sdef *sdefp)
sdef.ptype); sdef.ptype);
return -EINVAL; return -EINVAL;
} }
init_timer(&card->st_timer); timer_setup(&card->rb_timer, isdnloop_pollbchan, 0);
timer_setup(&card->st_timer, isdnloop_polldchan, 0);
card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD; card->st_timer.expires = jiffies + ISDNLOOP_TIMER_DCREAD;
card->st_timer.function = isdnloop_polldchan;
card->st_timer.data = (unsigned long) card;
add_timer(&card->st_timer); add_timer(&card->st_timer);
card->flags |= ISDNLOOP_FLAGS_RUNNING; card->flags |= ISDNLOOP_FLAGS_RUNNING;
spin_unlock_irqrestore(&card->isdnloop_lock, flags); spin_unlock_irqrestore(&card->isdnloop_lock, flags);

View File

@ -259,7 +259,7 @@ extern u8 *dsp_dtmf_goertzel_decode(struct dsp *dsp, u8 *data, int len,
extern int dsp_tone(struct dsp *dsp, int tone); 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_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_encrypt(struct dsp *dsp, u8 *data, int len);
extern void dsp_bf_decrypt(struct dsp *dsp, u8 *data, int len); extern void dsp_bf_decrypt(struct dsp *dsp, u8 *data, int len);

View File

@ -1092,7 +1092,7 @@ dspcreate(struct channel_req *crq)
ndsp->pcm_bank_tx = -1; ndsp->pcm_bank_tx = -1;
ndsp->hfc_conf = -1; /* current conference number */ ndsp->hfc_conf = -1; /* current conference number */
/* set tone timer */ /* 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) if (dtmfthreshold < 20 || dtmfthreshold > 500)
dtmfthreshold = 200; dtmfthreshold = 200;
@ -1202,9 +1202,7 @@ static int __init dsp_init(void)
} }
/* set sample timer */ /* set sample timer */
dsp_spl_tl.function = (void *)dsp_cmx_send; timer_setup(&dsp_spl_tl, (void *)dsp_cmx_send, 0);
dsp_spl_tl.data = 0;
init_timer(&dsp_spl_tl);
dsp_spl_tl.expires = jiffies + dsp_tics; dsp_spl_tl.expires = jiffies + dsp_tics;
dsp_spl_jiffies = dsp_spl_tl.expires; dsp_spl_jiffies = dsp_spl_tl.expires;
add_timer(&dsp_spl_tl); add_timer(&dsp_spl_tl);

View File

@ -457,9 +457,9 @@ dsp_tone_hw_message(struct dsp *dsp, u8 *sample, int len)
* timer expires * * timer expires *
*****************/ *****************/
void 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 dsp_tone *tone = &dsp->tone;
struct pattern *pat = (struct pattern *)tone->pattern; struct pattern *pat = (struct pattern *)tone->pattern;
int index = tone->index; int index = tone->index;
@ -478,7 +478,6 @@ dsp_tone_timeout(void *arg)
else else
dsp_tone_hw_message(dsp, pat->data[index], *(pat->siz[index])); dsp_tone_hw_message(dsp, pat->data[index], *(pat->siz[index]));
/* set timer */ /* set timer */
init_timer(&tone->tl);
tone->tl.expires = jiffies + (pat->seq[index] * HZ) / 8000; tone->tl.expires = jiffies + (pat->seq[index] * HZ) / 8000;
add_timer(&tone->tl); add_timer(&tone->tl);
} }
@ -541,7 +540,6 @@ dsp_tone(struct dsp *dsp, int tone)
/* set timer */ /* set timer */
if (timer_pending(&tonet->tl)) if (timer_pending(&tonet->tl))
del_timer(&tonet->tl); del_timer(&tonet->tl);
init_timer(&tonet->tl);
tonet->tl.expires = jiffies + (pat->seq[0] * HZ) / 8000; tonet->tl.expires = jiffies + (pat->seq[0] * HZ) / 8000;
add_timer(&tonet->tl); add_timer(&tonet->tl);
} else { } else {

View File

@ -100,8 +100,9 @@ mISDN_FsmChangeState(struct FsmInst *fi, int newstate)
EXPORT_SYMBOL(mISDN_FsmChangeState); EXPORT_SYMBOL(mISDN_FsmChangeState);
static void static void
FsmExpireTimer(struct FsmTimer *ft) FsmExpireTimer(struct timer_list *t)
{ {
struct FsmTimer *ft = from_timer(ft, t, tl);
#if FSM_TIMER_DEBUG #if FSM_TIMER_DEBUG
if (ft->fi->debug) if (ft->fi->debug)
ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft); ft->fi->printdebug(ft->fi, "FsmExpireTimer %lx", (long) ft);
@ -117,7 +118,7 @@ mISDN_FsmInitTimer(struct FsmInst *fi, struct FsmTimer *ft)
if (ft->fi->debug) if (ft->fi->debug)
ft->fi->printdebug(ft->fi, "mISDN_FsmInitTimer %lx", (long) ft); ft->fi->printdebug(ft->fi, "mISDN_FsmInitTimer %lx", (long) ft);
#endif #endif
setup_timer(&ft->tl, (void *)FsmExpireTimer, (long)ft); timer_setup(&ft->tl, FsmExpireTimer, 0);
} }
EXPORT_SYMBOL(mISDN_FsmInitTimer); EXPORT_SYMBOL(mISDN_FsmInitTimer);
@ -153,7 +154,6 @@ mISDN_FsmAddTimer(struct FsmTimer *ft,
} }
return -1; return -1;
} }
init_timer(&ft->tl);
ft->event = event; ft->event = event;
ft->arg = arg; ft->arg = arg;
ft->tl.expires = jiffies + (millisec * HZ) / 1000; ft->tl.expires = jiffies + (millisec * HZ) / 1000;
@ -175,7 +175,6 @@ mISDN_FsmRestartTimer(struct FsmTimer *ft,
if (timer_pending(&ft->tl)) if (timer_pending(&ft->tl))
del_timer(&ft->tl); del_timer(&ft->tl);
init_timer(&ft->tl);
ft->event = event; ft->event = event;
ft->arg = arg; ft->arg = arg;
ft->tl.expires = jiffies + (millisec * HZ) / 1000; ft->tl.expires = jiffies + (millisec * HZ) / 1000;

View File

@ -842,17 +842,18 @@ l1oip_send_bh(struct work_struct *work)
* timer stuff * timer stuff
*/ */
static void 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); schedule_work(&hc->workq);
} }
static void 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; struct dchannel *dch = hc->chan[hc->d_idx].dch;
if (debug & DEBUG_L1OIP_MSG) if (debug & DEBUG_L1OIP_MSG)
@ -1437,13 +1438,11 @@ init_card(struct l1oip *hc, int pri, int bundle)
if (ret) if (ret)
return ret; return ret;
hc->keep_tl.function = (void *)l1oip_keepalive; timer_setup(&hc->keep_tl, l1oip_keepalive, 0);
hc->keep_tl.data = (ulong)hc;
init_timer(&hc->keep_tl);
hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */ hc->keep_tl.expires = jiffies + 2 * HZ; /* two seconds first time */
add_timer(&hc->keep_tl); 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 */ hc->timeout_on = 0; /* state that we have timer off */
return 0; return 0;

View File

@ -162,9 +162,9 @@ mISDN_poll(struct file *filep, poll_table *wait)
} }
static void 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; u_long flags;
spin_lock_irqsave(&timer->dev->lock, flags); spin_lock_irqsave(&timer->dev->lock, flags);
@ -189,7 +189,7 @@ misdn_add_timer(struct mISDNtimerdev *dev, int timeout)
if (!timer) if (!timer)
return -ENOMEM; return -ENOMEM;
timer->dev = dev; 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); spin_lock_irq(&dev->lock);
id = timer->id = dev->next_id++; id = timer->id = dev->next_id++;
if (dev->next_id < 0) if (dev->next_id < 0)

View File

@ -694,6 +694,7 @@ static int do_read(struct net_device *dev, void *cbuf, int cbuflen,
/* end of idle handlers -- what should be seen is do_read, do_write */ /* end of idle handlers -- what should be seen is do_read, do_write */
static struct timer_list ltpc_timer; static struct timer_list ltpc_timer;
static struct net_device *ltpc_timer_dev;
static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev); static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev);
@ -867,10 +868,8 @@ static void set_multicast_list(struct net_device *dev)
static int ltpc_poll_counter; static int ltpc_poll_counter;
static void ltpc_poll(unsigned long l) static void ltpc_poll(struct timer_list *unused)
{ {
struct net_device *dev = (struct net_device *) l;
del_timer(&ltpc_timer); del_timer(&ltpc_timer);
if(debug & DEBUG_VERBOSE) { if(debug & DEBUG_VERBOSE) {
@ -881,13 +880,9 @@ static void ltpc_poll(unsigned long l)
ltpc_poll_counter--; ltpc_poll_counter--;
} }
if (!dev)
return; /* we've been downed */
/* poll 20 times per second */ /* poll 20 times per second */
idle(dev); idle(ltpc_timer_dev);
ltpc_timer.expires = jiffies + HZ/20; ltpc_timer.expires = jiffies + HZ/20;
add_timer(&ltpc_timer); add_timer(&ltpc_timer);
} }
@ -1165,7 +1160,8 @@ struct net_device * __init ltpc_probe(void)
dev->irq = 0; dev->irq = 0;
/* polled mode -- 20 times per second */ /* polled mode -- 20 times per second */
/* this is really, really slow... should it poll more often? */ /* this is really, really slow... should it poll more often? */
setup_timer(&ltpc_timer, ltpc_poll, (unsigned long)dev); ltpc_timer_dev = dev;
timer_setup(&ltpc_timer, ltpc_poll, 0);
ltpc_timer.expires = jiffies + HZ/20; ltpc_timer.expires = jiffies + HZ/20;
add_timer(&ltpc_timer); add_timer(&ltpc_timer);
@ -1252,8 +1248,6 @@ static void __exit ltpc_cleanup(void)
if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n"); if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n");
unregister_netdev(dev_ltpc); unregister_netdev(dev_ltpc);
ltpc_timer.data = 0; /* signal the poll routine that we're done */
del_timer_sync(&ltpc_timer); del_timer_sync(&ltpc_timer);
if(debug & DEBUG_VERBOSE) printk("freeing irq\n"); if(debug & DEBUG_VERBOSE) printk("freeing irq\n");

View File

@ -225,7 +225,7 @@ static unsigned short read_eeprom(unsigned int ioaddr, int index);
static void tc574_wait_for_completion(struct net_device *dev, int cmd); static void tc574_wait_for_completion(struct net_device *dev, int cmd);
static void tc574_reset(struct net_device *dev); static void tc574_reset(struct net_device *dev);
static void media_check(unsigned long arg); static void media_check(struct timer_list *t);
static int el3_open(struct net_device *dev); static int el3_open(struct net_device *dev);
static netdev_tx_t el3_start_xmit(struct sk_buff *skb, static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
struct net_device *dev); struct net_device *dev);
@ -377,7 +377,7 @@ static int tc574_config(struct pcmcia_device *link)
lp->autoselect = config & Autoselect ? 1 : 0; lp->autoselect = config & Autoselect ? 1 : 0;
} }
init_timer(&lp->media); timer_setup(&lp->media, media_check, 0);
{ {
int phy; int phy;
@ -681,8 +681,6 @@ static int el3_open(struct net_device *dev)
netif_start_queue(dev); netif_start_queue(dev);
tc574_reset(dev); tc574_reset(dev);
lp->media.function = media_check;
lp->media.data = (unsigned long) dev;
lp->media.expires = jiffies + HZ; lp->media.expires = jiffies + HZ;
add_timer(&lp->media); add_timer(&lp->media);
@ -859,10 +857,10 @@ static irqreturn_t el3_interrupt(int irq, void *dev_id)
(and as a last resort, poll the NIC for events), and to monitor (and as a last resort, poll the NIC for events), and to monitor
the MII, reporting changes in cable status. the MII, reporting changes in cable status.
*/ */
static void media_check(unsigned long arg) static void media_check(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) arg; struct el3_private *lp = from_timer(lp, t, media);
struct el3_private *lp = netdev_priv(dev); struct net_device *dev = lp->p_dev->priv;
unsigned int ioaddr = dev->base_addr; unsigned int ioaddr = dev->base_addr;
unsigned long flags; unsigned long flags;
unsigned short /* cable, */ media, partner; unsigned short /* cable, */ media, partner;

View File

@ -163,7 +163,7 @@ static void tc589_release(struct pcmcia_device *link);
static u16 read_eeprom(unsigned int ioaddr, int index); static u16 read_eeprom(unsigned int ioaddr, int index);
static void tc589_reset(struct net_device *dev); static void tc589_reset(struct net_device *dev);
static void media_check(unsigned long arg); static void media_check(struct timer_list *t);
static int el3_config(struct net_device *dev, struct ifmap *map); static int el3_config(struct net_device *dev, struct ifmap *map);
static int el3_open(struct net_device *dev); static int el3_open(struct net_device *dev);
static netdev_tx_t el3_start_xmit(struct sk_buff *skb, static netdev_tx_t el3_start_xmit(struct sk_buff *skb,
@ -517,7 +517,7 @@ static int el3_open(struct net_device *dev)
netif_start_queue(dev); netif_start_queue(dev);
tc589_reset(dev); tc589_reset(dev);
setup_timer(&lp->media, media_check, (unsigned long)dev); timer_setup(&lp->media, media_check, 0);
mod_timer(&lp->media, jiffies + HZ); mod_timer(&lp->media, jiffies + HZ);
dev_dbg(&link->dev, "%s: opened, status %4.4x.\n", dev_dbg(&link->dev, "%s: opened, status %4.4x.\n",
@ -676,10 +676,10 @@ static irqreturn_t el3_interrupt(int irq, void *dev_id)
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
} }
static void media_check(unsigned long arg) static void media_check(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)(arg); struct el3_private *lp = from_timer(lp, t, media);
struct el3_private *lp = netdev_priv(dev); struct net_device *dev = lp->p_dev->priv;
unsigned int ioaddr = dev->base_addr; unsigned int ioaddr = dev->base_addr;
u16 media, errs; u16 media, errs;
unsigned long flags; unsigned long flags;

View File

@ -759,8 +759,8 @@ static int vortex_open(struct net_device *dev);
static void mdio_sync(struct vortex_private *vp, int bits); static void mdio_sync(struct vortex_private *vp, int bits);
static int mdio_read(struct net_device *dev, int phy_id, int location); static int mdio_read(struct net_device *dev, int phy_id, int location);
static void mdio_write(struct net_device *vp, int phy_id, int location, int value); static void mdio_write(struct net_device *vp, int phy_id, int location, int value);
static void vortex_timer(unsigned long arg); static void vortex_timer(struct timer_list *t);
static void rx_oom_timer(unsigned long arg); static void rx_oom_timer(struct timer_list *t);
static netdev_tx_t vortex_start_xmit(struct sk_buff *skb, static netdev_tx_t vortex_start_xmit(struct sk_buff *skb,
struct net_device *dev); struct net_device *dev);
static netdev_tx_t boomerang_start_xmit(struct sk_buff *skb, static netdev_tx_t boomerang_start_xmit(struct sk_buff *skb,
@ -1599,9 +1599,9 @@ vortex_up(struct net_device *dev)
dev->name, media_tbl[dev->if_port].name); dev->name, media_tbl[dev->if_port].name);
} }
setup_timer(&vp->timer, vortex_timer, (unsigned long)dev); timer_setup(&vp->timer, vortex_timer, 0);
mod_timer(&vp->timer, RUN_AT(media_tbl[dev->if_port].wait)); mod_timer(&vp->timer, RUN_AT(media_tbl[dev->if_port].wait));
setup_timer(&vp->rx_oom_timer, rx_oom_timer, (unsigned long)dev); timer_setup(&vp->rx_oom_timer, rx_oom_timer, 0);
if (vortex_debug > 1) if (vortex_debug > 1)
pr_debug("%s: Initial media type %s.\n", pr_debug("%s: Initial media type %s.\n",
@ -1784,10 +1784,10 @@ out:
} }
static void static void
vortex_timer(unsigned long data) vortex_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct vortex_private *vp = from_timer(vp, t, timer);
struct vortex_private *vp = netdev_priv(dev); struct net_device *dev = vp->mii.dev;
void __iomem *ioaddr = vp->ioaddr; void __iomem *ioaddr = vp->ioaddr;
int next_tick = 60*HZ; int next_tick = 60*HZ;
int ok = 0; int ok = 0;
@ -2687,10 +2687,10 @@ boomerang_rx(struct net_device *dev)
* for some memory. Otherwise there is no way to restart the rx process. * for some memory. Otherwise there is no way to restart the rx process.
*/ */
static void static void
rx_oom_timer(unsigned long arg) rx_oom_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)arg; struct vortex_private *vp = from_timer(vp, t, rx_oom_timer);
struct vortex_private *vp = netdev_priv(dev); struct net_device *dev = vp->mii.dev;
spin_lock_irq(&vp->lock); spin_lock_irq(&vp->lock);
if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE) /* This test is redundant, but makes me feel good */ if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE) /* This test is redundant, but makes me feel good */

View File

@ -1669,9 +1669,9 @@ static int amd8111e_resume(struct pci_dev *pci_dev)
return 0; return 0;
} }
static void amd8111e_config_ipg(struct net_device *dev) static void amd8111e_config_ipg(struct timer_list *t)
{ {
struct amd8111e_priv *lp = netdev_priv(dev); struct amd8111e_priv *lp = from_timer(lp, t, ipg_data.ipg_timer);
struct ipg_info *ipg_data = &lp->ipg_data; struct ipg_info *ipg_data = &lp->ipg_data;
void __iomem *mmio = lp->mmio; void __iomem *mmio = lp->mmio;
unsigned int prev_col_cnt = ipg_data->col_cnt; unsigned int prev_col_cnt = ipg_data->col_cnt;
@ -1883,8 +1883,7 @@ static int amd8111e_probe_one(struct pci_dev *pdev,
/* Initialize software ipg timer */ /* Initialize software ipg timer */
if(lp->options & OPTION_DYN_IPG_ENABLE){ if(lp->options & OPTION_DYN_IPG_ENABLE){
setup_timer(&lp->ipg_data.ipg_timer, timer_setup(&lp->ipg_data.ipg_timer, amd8111e_config_ipg, 0);
(void *)&amd8111e_config_ipg, (unsigned long)dev);
lp->ipg_data.ipg_timer.expires = jiffies + lp->ipg_data.ipg_timer.expires = jiffies +
IPG_CONVERGE_JIFFIES; IPG_CONVERGE_JIFFIES;
lp->ipg_data.ipg = DEFAULT_IPG; lp->ipg_data.ipg = DEFAULT_IPG;

View File

@ -157,7 +157,7 @@ static irqreturn_t bmac_misc_intr(int irq, void *dev_id);
static irqreturn_t bmac_txdma_intr(int irq, void *dev_id); static irqreturn_t bmac_txdma_intr(int irq, void *dev_id);
static irqreturn_t bmac_rxdma_intr(int irq, void *dev_id); static irqreturn_t bmac_rxdma_intr(int irq, void *dev_id);
static void bmac_set_timeout(struct net_device *dev); static void bmac_set_timeout(struct net_device *dev);
static void bmac_tx_timeout(unsigned long data); static void bmac_tx_timeout(struct timer_list *t);
static int bmac_output(struct sk_buff *skb, struct net_device *dev); static int bmac_output(struct sk_buff *skb, struct net_device *dev);
static void bmac_start(struct net_device *dev); static void bmac_start(struct net_device *dev);
@ -555,8 +555,6 @@ static inline void bmac_set_timeout(struct net_device *dev)
if (bp->timeout_active) if (bp->timeout_active)
del_timer(&bp->tx_timeout); del_timer(&bp->tx_timeout);
bp->tx_timeout.expires = jiffies + TX_TIMEOUT; bp->tx_timeout.expires = jiffies + TX_TIMEOUT;
bp->tx_timeout.function = bmac_tx_timeout;
bp->tx_timeout.data = (unsigned long) dev;
add_timer(&bp->tx_timeout); add_timer(&bp->tx_timeout);
bp->timeout_active = 1; bp->timeout_active = 1;
spin_unlock_irqrestore(&bp->lock, flags); spin_unlock_irqrestore(&bp->lock, flags);
@ -1321,7 +1319,7 @@ static int bmac_probe(struct macio_dev *mdev, const struct of_device_id *match)
bp->queue = (struct sk_buff_head *)(bp->rx_cmds + N_RX_RING + 1); bp->queue = (struct sk_buff_head *)(bp->rx_cmds + N_RX_RING + 1);
skb_queue_head_init(bp->queue); skb_queue_head_init(bp->queue);
init_timer(&bp->tx_timeout); timer_setup(&bp->tx_timeout, bmac_tx_timeout, 0);
ret = request_irq(dev->irq, bmac_misc_intr, 0, "BMAC-misc", dev); ret = request_irq(dev->irq, bmac_misc_intr, 0, "BMAC-misc", dev);
if (ret) { if (ret) {
@ -1471,10 +1469,10 @@ bmac_output(struct sk_buff *skb, struct net_device *dev)
return NETDEV_TX_OK; return NETDEV_TX_OK;
} }
static void bmac_tx_timeout(unsigned long data) static void bmac_tx_timeout(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct bmac_data *bp = from_timer(bp, t, tx_timeout);
struct bmac_data *bp = netdev_priv(dev); struct net_device *dev = macio_get_drvdata(bp->mdev);
volatile struct dbdma_regs __iomem *td = bp->tx_dma; volatile struct dbdma_regs __iomem *td = bp->tx_dma;
volatile struct dbdma_regs __iomem *rd = bp->rx_dma; volatile struct dbdma_regs __iomem *rd = bp->rx_dma;
volatile struct dbdma_cmd *cp; volatile struct dbdma_cmd *cp;

View File

@ -86,7 +86,7 @@ static irqreturn_t mace_interrupt(int irq, void *dev_id);
static irqreturn_t mace_txdma_intr(int irq, void *dev_id); static irqreturn_t mace_txdma_intr(int irq, void *dev_id);
static irqreturn_t mace_rxdma_intr(int irq, void *dev_id); static irqreturn_t mace_rxdma_intr(int irq, void *dev_id);
static void mace_set_timeout(struct net_device *dev); static void mace_set_timeout(struct net_device *dev);
static void mace_tx_timeout(unsigned long data); static void mace_tx_timeout(struct timer_list *t);
static inline void dbdma_reset(volatile struct dbdma_regs __iomem *dma); static inline void dbdma_reset(volatile struct dbdma_regs __iomem *dma);
static inline void mace_clean_rings(struct mace_data *mp); static inline void mace_clean_rings(struct mace_data *mp);
static void __mace_set_address(struct net_device *dev, void *addr); static void __mace_set_address(struct net_device *dev, void *addr);
@ -196,7 +196,7 @@ static int mace_probe(struct macio_dev *mdev, const struct of_device_id *match)
memset((char *) mp->tx_cmds, 0, memset((char *) mp->tx_cmds, 0,
(NCMDS_TX*N_TX_RING + N_RX_RING + 2) * sizeof(struct dbdma_cmd)); (NCMDS_TX*N_TX_RING + N_RX_RING + 2) * sizeof(struct dbdma_cmd));
init_timer(&mp->tx_timeout); timer_setup(&mp->tx_timeout, mace_tx_timeout, 0);
spin_lock_init(&mp->lock); spin_lock_init(&mp->lock);
mp->timeout_active = 0; mp->timeout_active = 0;
@ -521,8 +521,6 @@ static inline void mace_set_timeout(struct net_device *dev)
if (mp->timeout_active) if (mp->timeout_active)
del_timer(&mp->tx_timeout); del_timer(&mp->tx_timeout);
mp->tx_timeout.expires = jiffies + TX_TIMEOUT; mp->tx_timeout.expires = jiffies + TX_TIMEOUT;
mp->tx_timeout.function = mace_tx_timeout;
mp->tx_timeout.data = (unsigned long) dev;
add_timer(&mp->tx_timeout); add_timer(&mp->tx_timeout);
mp->timeout_active = 1; mp->timeout_active = 1;
} }
@ -801,10 +799,10 @@ static irqreturn_t mace_interrupt(int irq, void *dev_id)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void mace_tx_timeout(unsigned long data) static void mace_tx_timeout(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct mace_data *mp = from_timer(mp, t, tx_timeout);
struct mace_data *mp = netdev_priv(dev); struct net_device *dev = macio_get_drvdata(mp->mdev);
volatile struct mace __iomem *mb = mp->mace; volatile struct mace __iomem *mb = mp->mace;
volatile struct dbdma_regs __iomem *td = mp->tx_dma; volatile struct dbdma_regs __iomem *td = mp->tx_dma;
volatile struct dbdma_regs __iomem *rd = mp->rx_dma; volatile struct dbdma_regs __iomem *rd = mp->rx_dma;

View File

@ -295,16 +295,13 @@ static int bcm_enet_refill_rx(struct net_device *dev)
/* /*
* timer callback to defer refill rx queue in case we're OOM * timer callback to defer refill rx queue in case we're OOM
*/ */
static void bcm_enet_refill_rx_timer(unsigned long data) static void bcm_enet_refill_rx_timer(struct timer_list *t)
{ {
struct net_device *dev; struct bcm_enet_priv *priv = from_timer(priv, t, rx_timeout);
struct bcm_enet_priv *priv; struct net_device *dev = priv->net_dev;
dev = (struct net_device *)data;
priv = netdev_priv(dev);
spin_lock(&priv->rx_lock); spin_lock(&priv->rx_lock);
bcm_enet_refill_rx((struct net_device *)data); bcm_enet_refill_rx(dev);
spin_unlock(&priv->rx_lock); spin_unlock(&priv->rx_lock);
} }
@ -1860,8 +1857,7 @@ static int bcm_enet_probe(struct platform_device *pdev)
spin_lock_init(&priv->rx_lock); spin_lock_init(&priv->rx_lock);
/* init rx timeout (used for oom) */ /* init rx timeout (used for oom) */
setup_timer(&priv->rx_timeout, bcm_enet_refill_rx_timer, timer_setup(&priv->rx_timeout, bcm_enet_refill_rx_timer, 0);
(unsigned long)dev);
/* init the mib update lock&work */ /* init the mib update lock&work */
mutex_init(&priv->mib_update_lock); mutex_init(&priv->mib_update_lock);
@ -2015,9 +2011,9 @@ static inline int bcm_enet_port_is_rgmii(int portid)
/* /*
* enet sw PHY polling * enet sw PHY polling
*/ */
static void swphy_poll_timer(unsigned long data) static void swphy_poll_timer(struct timer_list *t)
{ {
struct bcm_enet_priv *priv = (struct bcm_enet_priv *)data; struct bcm_enet_priv *priv = from_timer(priv, t, swphy_poll);
unsigned int i; unsigned int i;
for (i = 0; i < priv->num_ports; i++) { for (i = 0; i < priv->num_ports; i++) {
@ -2326,7 +2322,7 @@ static int bcm_enetsw_open(struct net_device *dev)
} }
/* start phy polling timer */ /* start phy polling timer */
setup_timer(&priv->swphy_poll, swphy_poll_timer, (unsigned long)priv); timer_setup(&priv->swphy_poll, swphy_poll_timer, 0);
mod_timer(&priv->swphy_poll, jiffies); mod_timer(&priv->swphy_poll, jiffies);
return 0; return 0;
@ -2743,9 +2739,7 @@ static int bcm_enetsw_probe(struct platform_device *pdev)
spin_lock_init(&priv->rx_lock); spin_lock_init(&priv->rx_lock);
/* init rx timeout (used for oom) */ /* init rx timeout (used for oom) */
init_timer(&priv->rx_timeout); timer_setup(&priv->rx_timeout, bcm_enet_refill_rx_timer, 0);
priv->rx_timeout.function = bcm_enet_refill_rx_timer;
priv->rx_timeout.data = (unsigned long)dev;
/* register netdevice */ /* register netdevice */
dev->netdev_ops = &bcm_enetsw_ops; dev->netdev_ops = &bcm_enetsw_ops;

View File

@ -1693,9 +1693,9 @@ err_return:
/* Timer callbacks */ /* Timer callbacks */
/* a) IOC timer */ /* a) IOC timer */
static void static void
bnad_ioc_timeout(unsigned long data) bnad_ioc_timeout(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.ioc_timer);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&bnad->bna_lock, flags); spin_lock_irqsave(&bnad->bna_lock, flags);
@ -1704,9 +1704,9 @@ bnad_ioc_timeout(unsigned long data)
} }
static void static void
bnad_ioc_hb_check(unsigned long data) bnad_ioc_hb_check(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.hb_timer);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&bnad->bna_lock, flags); spin_lock_irqsave(&bnad->bna_lock, flags);
@ -1715,9 +1715,9 @@ bnad_ioc_hb_check(unsigned long data)
} }
static void static void
bnad_iocpf_timeout(unsigned long data) bnad_iocpf_timeout(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.iocpf_timer);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&bnad->bna_lock, flags); spin_lock_irqsave(&bnad->bna_lock, flags);
@ -1726,9 +1726,9 @@ bnad_iocpf_timeout(unsigned long data)
} }
static void static void
bnad_iocpf_sem_timeout(unsigned long data) bnad_iocpf_sem_timeout(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, bna.ioceth.ioc.sem_timer);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&bnad->bna_lock, flags); spin_lock_irqsave(&bnad->bna_lock, flags);
@ -1748,9 +1748,9 @@ bnad_iocpf_sem_timeout(unsigned long data)
/* b) Dynamic Interrupt Moderation Timer */ /* b) Dynamic Interrupt Moderation Timer */
static void static void
bnad_dim_timeout(unsigned long data) bnad_dim_timeout(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, dim_timer);
struct bnad_rx_info *rx_info; struct bnad_rx_info *rx_info;
struct bnad_rx_ctrl *rx_ctrl; struct bnad_rx_ctrl *rx_ctrl;
int i, j; int i, j;
@ -1781,9 +1781,9 @@ bnad_dim_timeout(unsigned long data)
/* c) Statistics Timer */ /* c) Statistics Timer */
static void static void
bnad_stats_timeout(unsigned long data) bnad_stats_timeout(struct timer_list *t)
{ {
struct bnad *bnad = (struct bnad *)data; struct bnad *bnad = from_timer(bnad, t, stats_timer);
unsigned long flags; unsigned long flags;
if (!netif_running(bnad->netdev) || if (!netif_running(bnad->netdev) ||
@ -1804,8 +1804,7 @@ bnad_dim_timer_start(struct bnad *bnad)
{ {
if (bnad->cfg_flags & BNAD_CF_DIM_ENABLED && if (bnad->cfg_flags & BNAD_CF_DIM_ENABLED &&
!test_bit(BNAD_RF_DIM_TIMER_RUNNING, &bnad->run_flags)) { !test_bit(BNAD_RF_DIM_TIMER_RUNNING, &bnad->run_flags)) {
setup_timer(&bnad->dim_timer, bnad_dim_timeout, timer_setup(&bnad->dim_timer, bnad_dim_timeout, 0);
(unsigned long)bnad);
set_bit(BNAD_RF_DIM_TIMER_RUNNING, &bnad->run_flags); set_bit(BNAD_RF_DIM_TIMER_RUNNING, &bnad->run_flags);
mod_timer(&bnad->dim_timer, mod_timer(&bnad->dim_timer,
jiffies + msecs_to_jiffies(BNAD_DIM_TIMER_FREQ)); jiffies + msecs_to_jiffies(BNAD_DIM_TIMER_FREQ));
@ -1823,8 +1822,7 @@ bnad_stats_timer_start(struct bnad *bnad)
spin_lock_irqsave(&bnad->bna_lock, flags); spin_lock_irqsave(&bnad->bna_lock, flags);
if (!test_and_set_bit(BNAD_RF_STATS_TIMER_RUNNING, &bnad->run_flags)) { if (!test_and_set_bit(BNAD_RF_STATS_TIMER_RUNNING, &bnad->run_flags)) {
setup_timer(&bnad->stats_timer, bnad_stats_timeout, timer_setup(&bnad->stats_timer, bnad_stats_timeout, 0);
(unsigned long)bnad);
mod_timer(&bnad->stats_timer, mod_timer(&bnad->stats_timer,
jiffies + msecs_to_jiffies(BNAD_STATS_TIMER_FREQ)); jiffies + msecs_to_jiffies(BNAD_STATS_TIMER_FREQ));
} }
@ -3692,14 +3690,11 @@ bnad_pci_probe(struct pci_dev *pdev,
goto res_free; goto res_free;
/* Set up timers */ /* Set up timers */
setup_timer(&bnad->bna.ioceth.ioc.ioc_timer, bnad_ioc_timeout, timer_setup(&bnad->bna.ioceth.ioc.ioc_timer, bnad_ioc_timeout, 0);
(unsigned long)bnad); timer_setup(&bnad->bna.ioceth.ioc.hb_timer, bnad_ioc_hb_check, 0);
setup_timer(&bnad->bna.ioceth.ioc.hb_timer, bnad_ioc_hb_check, timer_setup(&bnad->bna.ioceth.ioc.iocpf_timer, bnad_iocpf_timeout, 0);
(unsigned long)bnad); timer_setup(&bnad->bna.ioceth.ioc.sem_timer, bnad_iocpf_sem_timeout,
setup_timer(&bnad->bna.ioceth.ioc.iocpf_timer, bnad_iocpf_timeout, 0);
(unsigned long)bnad);
setup_timer(&bnad->bna.ioceth.ioc.sem_timer, bnad_iocpf_sem_timeout,
(unsigned long)bnad);
/* /*
* Start the chip * Start the chip

View File

@ -1882,10 +1882,10 @@ send:
/* /*
* Callback for the Tx buffer reclaim timer. Runs with softirqs disabled. * Callback for the Tx buffer reclaim timer. Runs with softirqs disabled.
*/ */
static void sge_tx_reclaim_cb(unsigned long data) static void sge_tx_reclaim_cb(struct timer_list *t)
{ {
int i; int i;
struct sge *sge = (struct sge *)data; struct sge *sge = from_timer(sge, t, tx_reclaim_timer);
for (i = 0; i < SGE_CMDQ_N; ++i) { for (i = 0; i < SGE_CMDQ_N; ++i) {
struct cmdQ *q = &sge->cmdQ[i]; struct cmdQ *q = &sge->cmdQ[i];
@ -1978,10 +1978,10 @@ void t1_sge_start(struct sge *sge)
/* /*
* Callback for the T2 ESPI 'stuck packet feature' workaorund * Callback for the T2 ESPI 'stuck packet feature' workaorund
*/ */
static void espibug_workaround_t204(unsigned long data) static void espibug_workaround_t204(struct timer_list *t)
{ {
struct adapter *adapter = (struct adapter *)data; struct sge *sge = from_timer(sge, t, espibug_timer);
struct sge *sge = adapter->sge; struct adapter *adapter = sge->adapter;
unsigned int nports = adapter->params.nports; unsigned int nports = adapter->params.nports;
u32 seop[MAX_NPORTS]; u32 seop[MAX_NPORTS];
@ -2021,10 +2021,10 @@ static void espibug_workaround_t204(unsigned long data)
mod_timer(&sge->espibug_timer, jiffies + sge->espibug_timeout); mod_timer(&sge->espibug_timer, jiffies + sge->espibug_timeout);
} }
static void espibug_workaround(unsigned long data) static void espibug_workaround(struct timer_list *t)
{ {
struct adapter *adapter = (struct adapter *)data; struct sge *sge = from_timer(sge, t, espibug_timer);
struct sge *sge = adapter->sge; struct adapter *adapter = sge->adapter;
if (netif_running(adapter->port[0].dev)) { if (netif_running(adapter->port[0].dev)) {
struct sk_buff *skb = sge->espibug_skb[0]; struct sk_buff *skb = sge->espibug_skb[0];
@ -2075,18 +2075,15 @@ struct sge *t1_sge_create(struct adapter *adapter, struct sge_params *p)
goto nomem_port; goto nomem_port;
} }
setup_timer(&sge->tx_reclaim_timer, sge_tx_reclaim_cb, timer_setup(&sge->tx_reclaim_timer, sge_tx_reclaim_cb, 0);
(unsigned long)sge);
if (is_T2(sge->adapter)) { if (is_T2(sge->adapter)) {
init_timer(&sge->espibug_timer); timer_setup(&sge->espibug_timer,
adapter->params.nports > 1 ? espibug_workaround_t204 : espibug_workaround,
0);
if (adapter->params.nports > 1) { if (adapter->params.nports > 1)
tx_sched_init(sge); tx_sched_init(sge);
sge->espibug_timer.function = espibug_workaround_t204;
} else
sge->espibug_timer.function = espibug_workaround;
sge->espibug_timer.data = (unsigned long)sge->adapter;
sge->espibug_timeout = 1; sge->espibug_timeout = 1;
/* for T204, every 10ms */ /* for T204, every 10ms */

View File

@ -333,8 +333,8 @@ static void de_set_rx_mode (struct net_device *dev);
static void de_tx (struct de_private *de); static void de_tx (struct de_private *de);
static void de_clean_rings (struct de_private *de); static void de_clean_rings (struct de_private *de);
static void de_media_interrupt (struct de_private *de, u32 status); static void de_media_interrupt (struct de_private *de, u32 status);
static void de21040_media_timer (unsigned long data); static void de21040_media_timer (struct timer_list *t);
static void de21041_media_timer (unsigned long data); static void de21041_media_timer (struct timer_list *t);
static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media); static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
@ -959,9 +959,9 @@ static void de_next_media (struct de_private *de, const u32 *media,
} }
} }
static void de21040_media_timer (unsigned long data) static void de21040_media_timer (struct timer_list *t)
{ {
struct de_private *de = (struct de_private *) data; struct de_private *de = from_timer(de, t, media_timer);
struct net_device *dev = de->dev; struct net_device *dev = de->dev;
u32 status = dr32(SIAStatus); u32 status = dr32(SIAStatus);
unsigned int carrier; unsigned int carrier;
@ -1040,9 +1040,9 @@ static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
return 1; return 1;
} }
static void de21041_media_timer (unsigned long data) static void de21041_media_timer (struct timer_list *t)
{ {
struct de_private *de = (struct de_private *) data; struct de_private *de = from_timer(de, t, media_timer);
struct net_device *dev = de->dev; struct net_device *dev = de->dev;
u32 status = dr32(SIAStatus); u32 status = dr32(SIAStatus);
unsigned int carrier; unsigned int carrier;
@ -1999,12 +1999,9 @@ static int de_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug); de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
de->board_idx = board_idx; de->board_idx = board_idx;
spin_lock_init (&de->lock); spin_lock_init (&de->lock);
init_timer(&de->media_timer); timer_setup(&de->media_timer,
if (de->de21040) de->de21040 ? de21040_media_timer : de21041_media_timer,
de->media_timer.function = de21040_media_timer; 0);
else
de->media_timer.function = de21041_media_timer;
de->media_timer.data = (unsigned long) de;
netif_carrier_off(dev); netif_carrier_off(dev);

View File

@ -912,7 +912,7 @@ static int de4x5_init(struct net_device *dev);
static int de4x5_sw_reset(struct net_device *dev); static int de4x5_sw_reset(struct net_device *dev);
static int de4x5_rx(struct net_device *dev); static int de4x5_rx(struct net_device *dev);
static int de4x5_tx(struct net_device *dev); static int de4x5_tx(struct net_device *dev);
static void de4x5_ast(struct net_device *dev); static void de4x5_ast(struct timer_list *t);
static int de4x5_txur(struct net_device *dev); static int de4x5_txur(struct net_device *dev);
static int de4x5_rx_ovfc(struct net_device *dev); static int de4x5_rx_ovfc(struct net_device *dev);
@ -1147,8 +1147,7 @@ de4x5_hw_init(struct net_device *dev, u_long iobase, struct device *gendev)
lp->timeout = -1; lp->timeout = -1;
lp->gendev = gendev; lp->gendev = gendev;
spin_lock_init(&lp->lock); spin_lock_init(&lp->lock);
setup_timer(&lp->timer, (void (*)(unsigned long))de4x5_ast, timer_setup(&lp->timer, de4x5_ast, 0);
(unsigned long)dev);
de4x5_parse_params(dev); de4x5_parse_params(dev);
/* /*
@ -1741,9 +1740,10 @@ de4x5_tx(struct net_device *dev)
} }
static void static void
de4x5_ast(struct net_device *dev) de4x5_ast(struct timer_list *t)
{ {
struct de4x5_private *lp = netdev_priv(dev); struct de4x5_private *lp = from_timer(lp, t, timer);
struct net_device *dev = dev_get_drvdata(lp->gendev);
int next_tick = DE4X5_AUTOSENSE_MS; int next_tick = DE4X5_AUTOSENSE_MS;
int dt; int dt;
@ -2369,7 +2369,7 @@ autoconf_media(struct net_device *dev)
lp->media = INIT; lp->media = INIT;
lp->tcount = 0; lp->tcount = 0;
de4x5_ast(dev); de4x5_ast(&lp->timer);
return lp->media; return lp->media;
} }

View File

@ -331,7 +331,7 @@ static void dmfe_phy_write_1bit(void __iomem *, u32);
static u16 dmfe_phy_read_1bit(void __iomem *); static u16 dmfe_phy_read_1bit(void __iomem *);
static u8 dmfe_sense_speed(struct dmfe_board_info *); static u8 dmfe_sense_speed(struct dmfe_board_info *);
static void dmfe_process_mode(struct dmfe_board_info *); static void dmfe_process_mode(struct dmfe_board_info *);
static void dmfe_timer(unsigned long); static void dmfe_timer(struct timer_list *);
static inline u32 cal_CRC(unsigned char *, unsigned int, u8); static inline u32 cal_CRC(unsigned char *, unsigned int, u8);
static void dmfe_rx_packet(struct net_device *, struct dmfe_board_info *); static void dmfe_rx_packet(struct net_device *, struct dmfe_board_info *);
static void dmfe_free_tx_pkt(struct net_device *, struct dmfe_board_info *); static void dmfe_free_tx_pkt(struct net_device *, struct dmfe_board_info *);
@ -596,7 +596,7 @@ static int dmfe_open(struct net_device *dev)
netif_wake_queue(dev); netif_wake_queue(dev);
/* set and active a timer process */ /* set and active a timer process */
setup_timer(&db->timer, dmfe_timer, (unsigned long)dev); timer_setup(&db->timer, dmfe_timer, 0);
db->timer.expires = DMFE_TIMER_WUT + HZ * 2; db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
add_timer(&db->timer); add_timer(&db->timer);
@ -1128,10 +1128,10 @@ static const struct ethtool_ops netdev_ethtool_ops = {
* Dynamic media sense, allocate Rx buffer... * Dynamic media sense, allocate Rx buffer...
*/ */
static void dmfe_timer(unsigned long data) static void dmfe_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct dmfe_board_info *db = from_timer(db, t, timer);
struct dmfe_board_info *db = netdev_priv(dev); struct net_device *dev = pci_get_drvdata(db->pdev);
void __iomem *ioaddr = db->ioaddr; void __iomem *ioaddr = db->ioaddr;
u32 tmp_cr8; u32 tmp_cr8;
unsigned char tmp_cr12; unsigned char tmp_cr12;

View File

@ -102,10 +102,10 @@ int tulip_refill_rx(struct net_device *dev)
#ifdef CONFIG_TULIP_NAPI #ifdef CONFIG_TULIP_NAPI
void oom_timer(unsigned long data) void oom_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, oom_timer);
struct tulip_private *tp = netdev_priv(dev);
napi_schedule(&tp->napi); napi_schedule(&tp->napi);
} }

View File

@ -84,10 +84,10 @@ void pnic_lnk_change(struct net_device *dev, int csr5)
} }
} }
void pnic_timer(unsigned long data) void pnic_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, timer);
struct tulip_private *tp = netdev_priv(dev); struct net_device *dev = tp->dev;
void __iomem *ioaddr = tp->base_addr; void __iomem *ioaddr = tp->base_addr;
int next_tick = 60*HZ; int next_tick = 60*HZ;

View File

@ -76,10 +76,10 @@
#include <linux/delay.h> #include <linux/delay.h>
void pnic2_timer(unsigned long data) void pnic2_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, timer);
struct tulip_private *tp = netdev_priv(dev); struct net_device *dev = tp->dev;
void __iomem *ioaddr = tp->base_addr; void __iomem *ioaddr = tp->base_addr;
int next_tick = 60*HZ; int next_tick = 60*HZ;

View File

@ -137,10 +137,10 @@ void tulip_media_task(struct work_struct *work)
} }
void mxic_timer(unsigned long data) void mxic_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, timer);
struct tulip_private *tp = netdev_priv(dev); struct net_device *dev = tp->dev;
void __iomem *ioaddr = tp->base_addr; void __iomem *ioaddr = tp->base_addr;
int next_tick = 60*HZ; int next_tick = 60*HZ;
@ -154,10 +154,10 @@ void mxic_timer(unsigned long data)
} }
void comet_timer(unsigned long data) void comet_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, timer);
struct tulip_private *tp = netdev_priv(dev); struct net_device *dev = tp->dev;
int next_tick = 2*HZ; int next_tick = 2*HZ;
if (tulip_debug > 1) if (tulip_debug > 1)

View File

@ -43,7 +43,7 @@ struct tulip_chip_table {
int io_size; int io_size;
int valid_intrs; /* CSR7 interrupt enable settings */ int valid_intrs; /* CSR7 interrupt enable settings */
int flags; int flags;
void (*media_timer) (unsigned long); void (*media_timer) (struct timer_list *);
work_func_t media_task; work_func_t media_task;
}; };
@ -476,7 +476,7 @@ void t21142_lnk_change(struct net_device *dev, int csr5);
/* PNIC2.c */ /* PNIC2.c */
void pnic2_lnk_change(struct net_device *dev, int csr5); void pnic2_lnk_change(struct net_device *dev, int csr5);
void pnic2_timer(unsigned long data); void pnic2_timer(struct timer_list *t);
void pnic2_start_nway(struct net_device *dev); void pnic2_start_nway(struct net_device *dev);
void pnic2_lnk_change(struct net_device *dev, int csr5); void pnic2_lnk_change(struct net_device *dev, int csr5);
@ -504,19 +504,19 @@ void tulip_find_mii (struct net_device *dev, int board_idx);
/* pnic.c */ /* pnic.c */
void pnic_do_nway(struct net_device *dev); void pnic_do_nway(struct net_device *dev);
void pnic_lnk_change(struct net_device *dev, int csr5); void pnic_lnk_change(struct net_device *dev, int csr5);
void pnic_timer(unsigned long data); void pnic_timer(struct timer_list *t);
/* timer.c */ /* timer.c */
void tulip_media_task(struct work_struct *work); void tulip_media_task(struct work_struct *work);
void mxic_timer(unsigned long data); void mxic_timer(struct timer_list *t);
void comet_timer(unsigned long data); void comet_timer(struct timer_list *t);
/* tulip_core.c */ /* tulip_core.c */
extern int tulip_debug; extern int tulip_debug;
extern const char * const medianame[]; extern const char * const medianame[];
extern const char tulip_media_cap[]; extern const char tulip_media_cap[];
extern const struct tulip_chip_table tulip_tbl[]; extern const struct tulip_chip_table tulip_tbl[];
void oom_timer(unsigned long data); void oom_timer(struct timer_list *t);
extern u8 t21040_csr13[]; extern u8 t21040_csr13[];
static inline void tulip_start_rxtx(struct tulip_private *tp) static inline void tulip_start_rxtx(struct tulip_private *tp)

View File

@ -123,10 +123,10 @@ int tulip_debug = TULIP_DEBUG;
int tulip_debug = 1; int tulip_debug = 1;
#endif #endif
static void tulip_timer(unsigned long data) static void tulip_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct tulip_private *tp = from_timer(tp, t, timer);
struct tulip_private *tp = netdev_priv(dev); struct net_device *dev = tp->dev;
if (netif_running(dev)) if (netif_running(dev))
schedule_work(&tp->media_work); schedule_work(&tp->media_work);
@ -505,7 +505,7 @@ media_picked:
tp->timer.expires = RUN_AT(next_tick); tp->timer.expires = RUN_AT(next_tick);
add_timer(&tp->timer); add_timer(&tp->timer);
#ifdef CONFIG_TULIP_NAPI #ifdef CONFIG_TULIP_NAPI
setup_timer(&tp->oom_timer, oom_timer, (unsigned long)dev); timer_setup(&tp->oom_timer, oom_timer, 0);
#endif #endif
} }
@ -780,8 +780,7 @@ static void tulip_down (struct net_device *dev)
spin_unlock_irqrestore (&tp->lock, flags); spin_unlock_irqrestore (&tp->lock, flags);
setup_timer(&tp->timer, tulip_tbl[tp->chip_id].media_timer, timer_setup(&tp->timer, tulip_tbl[tp->chip_id].media_timer, 0);
(unsigned long)dev);
dev->if_port = tp->saved_if_port; dev->if_port = tp->saved_if_port;
@ -1470,8 +1469,7 @@ static int tulip_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
tp->csr0 = csr0; tp->csr0 = csr0;
spin_lock_init(&tp->lock); spin_lock_init(&tp->lock);
spin_lock_init(&tp->mii_lock); spin_lock_init(&tp->mii_lock);
setup_timer(&tp->timer, tulip_tbl[tp->chip_id].media_timer, timer_setup(&tp->timer, tulip_tbl[tp->chip_id].media_timer, 0);
(unsigned long)dev);
INIT_WORK(&tp->media_work, tulip_tbl[tp->chip_id].media_task); INIT_WORK(&tp->media_work, tulip_tbl[tp->chip_id].media_task);

View File

@ -241,7 +241,7 @@ static void phy_write_1bit(struct uli526x_board_info *db, u32);
static u16 phy_read_1bit(struct uli526x_board_info *db); static u16 phy_read_1bit(struct uli526x_board_info *db);
static u8 uli526x_sense_speed(struct uli526x_board_info *); static u8 uli526x_sense_speed(struct uli526x_board_info *);
static void uli526x_process_mode(struct uli526x_board_info *); static void uli526x_process_mode(struct uli526x_board_info *);
static void uli526x_timer(unsigned long); static void uli526x_timer(struct timer_list *t);
static void uli526x_rx_packet(struct net_device *, struct uli526x_board_info *); static void uli526x_rx_packet(struct net_device *, struct uli526x_board_info *);
static void uli526x_free_tx_pkt(struct net_device *, struct uli526x_board_info *); static void uli526x_free_tx_pkt(struct net_device *, struct uli526x_board_info *);
static void uli526x_reuse_skb(struct uli526x_board_info *, struct sk_buff *); static void uli526x_reuse_skb(struct uli526x_board_info *, struct sk_buff *);
@ -491,7 +491,7 @@ static int uli526x_open(struct net_device *dev)
netif_wake_queue(dev); netif_wake_queue(dev);
/* set and active a timer process */ /* set and active a timer process */
setup_timer(&db->timer, uli526x_timer, (unsigned long)dev); timer_setup(&db->timer, uli526x_timer, 0);
db->timer.expires = ULI526X_TIMER_WUT + HZ * 2; db->timer.expires = ULI526X_TIMER_WUT + HZ * 2;
add_timer(&db->timer); add_timer(&db->timer);
@ -1021,10 +1021,10 @@ static const struct ethtool_ops netdev_ethtool_ops = {
* Dynamic media sense, allocate Rx buffer... * Dynamic media sense, allocate Rx buffer...
*/ */
static void uli526x_timer(unsigned long data) static void uli526x_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct uli526x_board_info *db = from_timer(db, t, timer);
struct uli526x_board_info *db = netdev_priv(dev); struct net_device *dev = pci_get_drvdata(db->pdev);
struct uli_phy_ops *phy = &db->phy; struct uli_phy_ops *phy = &db->phy;
void __iomem *ioaddr = db->ioaddr; void __iomem *ioaddr = db->ioaddr;
unsigned long flags; unsigned long flags;

View File

@ -327,7 +327,7 @@ static int mdio_read(struct net_device *dev, int phy_id, int location);
static void mdio_write(struct net_device *dev, int phy_id, int location, int value); static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
static int netdev_open(struct net_device *dev); static int netdev_open(struct net_device *dev);
static int update_link(struct net_device *dev); static int update_link(struct net_device *dev);
static void netdev_timer(unsigned long data); static void netdev_timer(struct timer_list *t);
static void init_rxtx_rings(struct net_device *dev); static void init_rxtx_rings(struct net_device *dev);
static void free_rxtx_rings(struct netdev_private *np); static void free_rxtx_rings(struct netdev_private *np);
static void init_registers(struct net_device *dev); static void init_registers(struct net_device *dev);
@ -655,7 +655,7 @@ static int netdev_open(struct net_device *dev)
netdev_dbg(dev, "Done netdev_open()\n"); netdev_dbg(dev, "Done netdev_open()\n");
/* Set the timer to check for link beat. */ /* Set the timer to check for link beat. */
setup_timer(&np->timer, netdev_timer, (unsigned long)dev); timer_setup(&np->timer, netdev_timer, 0);
np->timer.expires = jiffies + 1*HZ; np->timer.expires = jiffies + 1*HZ;
add_timer(&np->timer); add_timer(&np->timer);
return 0; return 0;
@ -772,10 +772,10 @@ static inline void update_csr6(struct net_device *dev, int new)
np->mii_if.full_duplex = 1; np->mii_if.full_duplex = 1;
} }
static void netdev_timer(unsigned long data) static void netdev_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct netdev_private *np = from_timer(np, t, timer);
struct netdev_private *np = netdev_priv(dev); struct net_device *dev = pci_get_drvdata(np->pci_dev);
void __iomem *ioaddr = np->base_addr; void __iomem *ioaddr = np->base_addr;
if (debug > 2) if (debug > 2)

View File

@ -68,7 +68,7 @@ static const int max_intrloop = 50;
static const int multicast_filter_limit = 0x40; static const int multicast_filter_limit = 0x40;
static int rio_open (struct net_device *dev); static int rio_open (struct net_device *dev);
static void rio_timer (unsigned long data); static void rio_timer (struct timer_list *t);
static void rio_tx_timeout (struct net_device *dev); static void rio_tx_timeout (struct net_device *dev);
static netdev_tx_t start_xmit (struct sk_buff *skb, struct net_device *dev); static netdev_tx_t start_xmit (struct sk_buff *skb, struct net_device *dev);
static irqreturn_t rio_interrupt (int irq, void *dev_instance); static irqreturn_t rio_interrupt (int irq, void *dev_instance);
@ -644,7 +644,7 @@ static int rio_open(struct net_device *dev)
return i; return i;
} }
setup_timer(&np->timer, rio_timer, (unsigned long)dev); timer_setup(&np->timer, rio_timer, 0);
np->timer.expires = jiffies + 1 * HZ; np->timer.expires = jiffies + 1 * HZ;
add_timer(&np->timer); add_timer(&np->timer);
@ -655,10 +655,10 @@ static int rio_open(struct net_device *dev)
} }
static void static void
rio_timer (unsigned long data) rio_timer (struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct netdev_private *np = from_timer(np, t, timer);
struct netdev_private *np = netdev_priv(dev); struct net_device *dev = pci_get_drvdata(np->pdev);
unsigned int entry; unsigned int entry;
int next_tick = 1*HZ; int next_tick = 1*HZ;
unsigned long flags; unsigned long flags;

View File

@ -1023,8 +1023,6 @@ static int fs_enet_probe(struct platform_device *ofdev)
ndev->ethtool_ops = &fs_ethtool_ops; ndev->ethtool_ops = &fs_ethtool_ops;
init_timer(&fep->phy_timer_list);
netif_carrier_off(ndev); netif_carrier_off(ndev);
ndev->features |= NETIF_F_SG; ndev->features |= NETIF_F_SG;

View File

@ -137,7 +137,6 @@ struct fs_enet_private {
cbd_t __iomem *cur_rx; cbd_t __iomem *cur_rx;
cbd_t __iomem *cur_tx; cbd_t __iomem *cur_tx;
int tx_free; int tx_free;
struct timer_list phy_timer_list;
const struct phy_info *phy; const struct phy_info *phy;
u32 msg_enable; u32 msg_enable;
struct mii_if_info mii_if; struct mii_if_info mii_if;

View File

@ -2159,9 +2159,9 @@ static void hns_nic_task_schedule(struct hns_nic_priv *priv)
(void)schedule_work(&priv->service_task); (void)schedule_work(&priv->service_task);
} }
static void hns_nic_service_timer(unsigned long data) static void hns_nic_service_timer(struct timer_list *t)
{ {
struct hns_nic_priv *priv = (struct hns_nic_priv *)data; struct hns_nic_priv *priv = from_timer(priv, t, service_timer);
(void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ); (void)mod_timer(&priv->service_timer, jiffies + SERVICE_TIMER_HZ);
@ -2451,8 +2451,7 @@ static int hns_nic_dev_probe(struct platform_device *pdev)
/* carrier off reporting is important to ethtool even BEFORE open */ /* carrier off reporting is important to ethtool even BEFORE open */
netif_carrier_off(ndev); netif_carrier_off(ndev);
setup_timer(&priv->service_timer, hns_nic_service_timer, timer_setup(&priv->service_timer, hns_nic_service_timer, 0);
(unsigned long)priv);
INIT_WORK(&priv->service_task, hns_nic_service_task); INIT_WORK(&priv->service_task, hns_nic_service_task);
set_bit(NIC_STATE_SERVICE_INITED, &priv->state); set_bit(NIC_STATE_SERVICE_INITED, &priv->state);

View File

@ -2350,11 +2350,11 @@ static int hclge_get_status(struct hnae3_handle *handle)
return hdev->hw.mac.link; return hdev->hw.mac.link;
} }
static void hclge_service_timer(unsigned long data) static void hclge_service_timer(struct timer_list *t)
{ {
struct hclge_dev *hdev = (struct hclge_dev *)data; struct hclge_dev *hdev = from_timer(hdev, t, service_timer);
(void)mod_timer(&hdev->service_timer, jiffies + HZ);
mod_timer(&hdev->service_timer, jiffies + HZ);
hclge_task_schedule(hdev); hclge_task_schedule(hdev);
} }
@ -3204,7 +3204,7 @@ static int hclge_ae_start(struct hnae3_handle *handle)
/* mac enable */ /* mac enable */
hclge_cfg_mac_mode(hdev, true); hclge_cfg_mac_mode(hdev, true);
clear_bit(HCLGE_STATE_DOWN, &hdev->state); clear_bit(HCLGE_STATE_DOWN, &hdev->state);
(void)mod_timer(&hdev->service_timer, jiffies + HZ); mod_timer(&hdev->service_timer, jiffies + HZ);
ret = hclge_mac_start_phy(hdev); ret = hclge_mac_start_phy(hdev);
if (ret) if (ret)
@ -4436,8 +4436,7 @@ static int hclge_init_ae_dev(struct hnae3_ae_dev *ae_dev)
hclge_dcb_ops_set(hdev); hclge_dcb_ops_set(hdev);
setup_timer(&hdev->service_timer, hclge_service_timer, timer_setup(&hdev->service_timer, hclge_service_timer, 0);
(unsigned long)hdev);
INIT_WORK(&hdev->service_task, hclge_service_task); INIT_WORK(&hdev->service_task, hclge_service_task);
set_bit(HCLGE_STATE_SERVICE_INITED, &hdev->state); set_bit(HCLGE_STATE_SERVICE_INITED, &hdev->state);
@ -4464,7 +4463,7 @@ static void hclge_uninit_ae_dev(struct hnae3_ae_dev *ae_dev)
if (IS_ENABLED(CONFIG_PCI_IOV)) if (IS_ENABLED(CONFIG_PCI_IOV))
hclge_disable_sriov(hdev); hclge_disable_sriov(hdev);
if (hdev->service_timer.data) if (hdev->service_timer.function)
del_timer_sync(&hdev->service_timer); del_timer_sync(&hdev->service_timer);
if (hdev->service_task.func) if (hdev->service_task.func)
cancel_work_sync(&hdev->service_task); cancel_work_sync(&hdev->service_task);

View File

@ -1710,9 +1710,9 @@ static void e100_adjust_adaptive_ifs(struct nic *nic, int speed, int duplex)
} }
} }
static void e100_watchdog(unsigned long data) static void e100_watchdog(struct timer_list *t)
{ {
struct nic *nic = (struct nic *)data; struct nic *nic = from_timer(nic, t, watchdog);
struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET }; struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
u32 speed; u32 speed;
@ -2920,7 +2920,7 @@ static int e100_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
pci_set_master(pdev); pci_set_master(pdev);
setup_timer(&nic->watchdog, e100_watchdog, (unsigned long)nic); timer_setup(&nic->watchdog, e100_watchdog, 0);
INIT_WORK(&nic->tx_timeout_task, e100_tx_timeout_task); INIT_WORK(&nic->tx_timeout_task, e100_tx_timeout_task);

View File

@ -4823,9 +4823,9 @@ static void e1000e_update_phy_task(struct work_struct *work)
* Need to wait a few seconds after link up to get diagnostic information from * Need to wait a few seconds after link up to get diagnostic information from
* the phy * the phy
**/ **/
static void e1000_update_phy_info(unsigned long data) static void e1000_update_phy_info(struct timer_list *t)
{ {
struct e1000_adapter *adapter = (struct e1000_adapter *)data; struct e1000_adapter *adapter = from_timer(adapter, t, phy_info_timer);
if (test_bit(__E1000_DOWN, &adapter->state)) if (test_bit(__E1000_DOWN, &adapter->state))
return; return;
@ -5159,9 +5159,9 @@ static void e1000e_check_82574_phy_workaround(struct e1000_adapter *adapter)
* e1000_watchdog - Timer Call-back * e1000_watchdog - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
**/ **/
static void e1000_watchdog(unsigned long data) static void e1000_watchdog(struct timer_list *t)
{ {
struct e1000_adapter *adapter = (struct e1000_adapter *)data; struct e1000_adapter *adapter = from_timer(adapter, t, watchdog_timer);
/* Do the rest outside of interrupt context */ /* Do the rest outside of interrupt context */
schedule_work(&adapter->watchdog_task); schedule_work(&adapter->watchdog_task);
@ -7267,10 +7267,8 @@ static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
goto err_eeprom; goto err_eeprom;
} }
setup_timer(&adapter->watchdog_timer, e1000_watchdog, timer_setup(&adapter->watchdog_timer, e1000_watchdog, 0);
(unsigned long)adapter); timer_setup(&adapter->phy_info_timer, e1000_update_phy_info, 0);
setup_timer(&adapter->phy_info_timer, e1000_update_phy_info,
(unsigned long)adapter);
INIT_WORK(&adapter->reset_task, e1000_reset_task); INIT_WORK(&adapter->reset_task, e1000_reset_task);
INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task); INIT_WORK(&adapter->watchdog_task, e1000_watchdog_task);

View File

@ -213,9 +213,10 @@ static void fm10k_start_service_event(struct fm10k_intfc *interface)
* fm10k_service_timer - Timer Call-back * fm10k_service_timer - Timer Call-back
* @data: pointer to interface cast into an unsigned long * @data: pointer to interface cast into an unsigned long
**/ **/
static void fm10k_service_timer(unsigned long data) static void fm10k_service_timer(struct timer_list *t)
{ {
struct fm10k_intfc *interface = (struct fm10k_intfc *)data; struct fm10k_intfc *interface = from_timer(interface, t,
service_timer);
/* Reset the timer */ /* Reset the timer */
mod_timer(&interface->service_timer, (HZ * 2) + jiffies); mod_timer(&interface->service_timer, (HZ * 2) + jiffies);
@ -2315,8 +2316,7 @@ static int fm10k_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
/* Initialize service timer and service task late in order to avoid /* Initialize service timer and service task late in order to avoid
* cleanup issues. * cleanup issues.
*/ */
setup_timer(&interface->service_timer, &fm10k_service_timer, timer_setup(&interface->service_timer, fm10k_service_timer, 0);
(unsigned long)interface);
INIT_WORK(&interface->service_task, fm10k_service_task); INIT_WORK(&interface->service_task, fm10k_service_task);
/* Setup the MAC/VLAN queue */ /* Setup the MAC/VLAN queue */

View File

@ -8800,9 +8800,9 @@ static void i40e_service_task(struct work_struct *work)
* i40e_service_timer - timer callback * i40e_service_timer - timer callback
* @data: pointer to PF struct * @data: pointer to PF struct
**/ **/
static void i40e_service_timer(unsigned long data) static void i40e_service_timer(struct timer_list *t)
{ {
struct i40e_pf *pf = (struct i40e_pf *)data; struct i40e_pf *pf = from_timer(pf, t, service_timer);
mod_timer(&pf->service_timer, mod_timer(&pf->service_timer,
round_jiffies(jiffies + pf->service_timer_period)); round_jiffies(jiffies + pf->service_timer_period));
@ -12648,7 +12648,7 @@ static int i40e_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
#endif /* CONFIG_I40E_DCB */ #endif /* CONFIG_I40E_DCB */
/* set up periodic task facility */ /* set up periodic task facility */
setup_timer(&pf->service_timer, i40e_service_timer, (unsigned long)pf); timer_setup(&pf->service_timer, i40e_service_timer, 0);
pf->service_timer_period = HZ; pf->service_timer_period = HZ;
INIT_WORK(&pf->service_task, i40e_service_task); INIT_WORK(&pf->service_task, i40e_service_task);
@ -12972,7 +12972,7 @@ static void i40e_remove(struct pci_dev *pdev)
/* no more scheduling of any task */ /* no more scheduling of any task */
set_bit(__I40E_SUSPENDED, pf->state); set_bit(__I40E_SUSPENDED, pf->state);
set_bit(__I40E_DOWN, pf->state); set_bit(__I40E_DOWN, pf->state);
if (pf->service_timer.data) if (pf->service_timer.function)
del_timer_sync(&pf->service_timer); del_timer_sync(&pf->service_timer);
if (pf->service_task.func) if (pf->service_task.func)
cancel_work_sync(&pf->service_task); cancel_work_sync(&pf->service_task);

View File

@ -1594,9 +1594,10 @@ err:
* i40evf_watchdog_timer - Periodic call-back timer * i40evf_watchdog_timer - Periodic call-back timer
* @data: pointer to adapter disguised as unsigned long * @data: pointer to adapter disguised as unsigned long
**/ **/
static void i40evf_watchdog_timer(unsigned long data) static void i40evf_watchdog_timer(struct timer_list *t)
{ {
struct i40evf_adapter *adapter = (struct i40evf_adapter *)data; struct i40evf_adapter *adapter = from_timer(adapter, t,
watchdog_timer);
schedule_work(&adapter->watchdog_task); schedule_work(&adapter->watchdog_task);
/* timer will be rescheduled in watchdog task */ /* timer will be rescheduled in watchdog task */
@ -2748,8 +2749,7 @@ static void i40evf_init_task(struct work_struct *work)
ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr); ether_addr_copy(netdev->perm_addr, adapter->hw.mac.addr);
} }
setup_timer(&adapter->watchdog_timer, &i40evf_watchdog_timer, timer_setup(&adapter->watchdog_timer, i40evf_watchdog_timer, 0);
(unsigned long)adapter);
mod_timer(&adapter->watchdog_timer, jiffies + 1); mod_timer(&adapter->watchdog_timer, jiffies + 1);
adapter->tx_desc_count = I40EVF_DEFAULT_TXD; adapter->tx_desc_count = I40EVF_DEFAULT_TXD;

View File

@ -133,8 +133,8 @@ static void igb_clean_all_rx_rings(struct igb_adapter *);
static void igb_clean_tx_ring(struct igb_ring *); static void igb_clean_tx_ring(struct igb_ring *);
static void igb_clean_rx_ring(struct igb_ring *); static void igb_clean_rx_ring(struct igb_ring *);
static void igb_set_rx_mode(struct net_device *); static void igb_set_rx_mode(struct net_device *);
static void igb_update_phy_info(unsigned long); static void igb_update_phy_info(struct timer_list *);
static void igb_watchdog(unsigned long); static void igb_watchdog(struct timer_list *);
static void igb_watchdog_task(struct work_struct *); static void igb_watchdog_task(struct work_struct *);
static netdev_tx_t igb_xmit_frame(struct sk_buff *skb, struct net_device *); static netdev_tx_t igb_xmit_frame(struct sk_buff *skb, struct net_device *);
static void igb_get_stats64(struct net_device *dev, static void igb_get_stats64(struct net_device *dev,
@ -2538,10 +2538,8 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
wr32(E1000_TXPBS, I210_TXPBSIZE_DEFAULT); wr32(E1000_TXPBS, I210_TXPBSIZE_DEFAULT);
} }
setup_timer(&adapter->watchdog_timer, igb_watchdog, timer_setup(&adapter->watchdog_timer, igb_watchdog, 0);
(unsigned long) adapter); timer_setup(&adapter->phy_info_timer, igb_update_phy_info, 0);
setup_timer(&adapter->phy_info_timer, igb_update_phy_info,
(unsigned long) adapter);
INIT_WORK(&adapter->reset_task, igb_reset_task); INIT_WORK(&adapter->reset_task, igb_reset_task);
INIT_WORK(&adapter->watchdog_task, igb_watchdog_task); INIT_WORK(&adapter->watchdog_task, igb_watchdog_task);
@ -4425,9 +4423,9 @@ static void igb_spoof_check(struct igb_adapter *adapter)
/* Need to wait a few seconds after link up to get diagnostic information from /* Need to wait a few seconds after link up to get diagnostic information from
* the phy * the phy
*/ */
static void igb_update_phy_info(unsigned long data) static void igb_update_phy_info(struct timer_list *t)
{ {
struct igb_adapter *adapter = (struct igb_adapter *) data; struct igb_adapter *adapter = from_timer(adapter, t, phy_info_timer);
igb_get_phy_info(&adapter->hw); igb_get_phy_info(&adapter->hw);
} }
@ -4514,9 +4512,9 @@ static void igb_check_lvmmc(struct igb_adapter *adapter)
* igb_watchdog - Timer Call-back * igb_watchdog - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
**/ **/
static void igb_watchdog(unsigned long data) static void igb_watchdog(struct timer_list *t)
{ {
struct igb_adapter *adapter = (struct igb_adapter *)data; struct igb_adapter *adapter = from_timer(adapter, t, watchdog_timer);
/* Do the rest outside of interrupt context */ /* Do the rest outside of interrupt context */
schedule_work(&adapter->watchdog_task); schedule_work(&adapter->watchdog_task);
} }

View File

@ -1915,9 +1915,9 @@ static bool igbvf_has_link(struct igbvf_adapter *adapter)
* igbvf_watchdog - Timer Call-back * igbvf_watchdog - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
**/ **/
static void igbvf_watchdog(unsigned long data) static void igbvf_watchdog(struct timer_list *t)
{ {
struct igbvf_adapter *adapter = (struct igbvf_adapter *)data; struct igbvf_adapter *adapter = from_timer(adapter, t, watchdog_timer);
/* Do the rest outside of interrupt context */ /* Do the rest outside of interrupt context */
schedule_work(&adapter->watchdog_task); schedule_work(&adapter->watchdog_task);
@ -2878,8 +2878,7 @@ static int igbvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
netdev->addr_len); netdev->addr_len);
} }
setup_timer(&adapter->watchdog_timer, &igbvf_watchdog, timer_setup(&adapter->watchdog_timer, igbvf_watchdog, 0);
(unsigned long)adapter);
INIT_WORK(&adapter->reset_task, igbvf_reset_task); INIT_WORK(&adapter->reset_task, igbvf_reset_task);
INIT_WORK(&adapter->watchdog_task, igbvf_watchdog_task); INIT_WORK(&adapter->watchdog_task, igbvf_watchdog_task);

View File

@ -83,7 +83,7 @@ static void ixgb_setup_rctl(struct ixgb_adapter *adapter);
static void ixgb_clean_tx_ring(struct ixgb_adapter *adapter); static void ixgb_clean_tx_ring(struct ixgb_adapter *adapter);
static void ixgb_clean_rx_ring(struct ixgb_adapter *adapter); static void ixgb_clean_rx_ring(struct ixgb_adapter *adapter);
static void ixgb_set_multi(struct net_device *netdev); static void ixgb_set_multi(struct net_device *netdev);
static void ixgb_watchdog(unsigned long data); static void ixgb_watchdog(struct timer_list *t);
static netdev_tx_t ixgb_xmit_frame(struct sk_buff *skb, static netdev_tx_t ixgb_xmit_frame(struct sk_buff *skb,
struct net_device *netdev); struct net_device *netdev);
static int ixgb_change_mtu(struct net_device *netdev, int new_mtu); static int ixgb_change_mtu(struct net_device *netdev, int new_mtu);
@ -508,8 +508,7 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw); adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw);
setup_timer(&adapter->watchdog_timer, ixgb_watchdog, timer_setup(&adapter->watchdog_timer, ixgb_watchdog, 0);
(unsigned long)adapter);
INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task); INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task);
@ -1151,9 +1150,9 @@ alloc_failed:
**/ **/
static void static void
ixgb_watchdog(unsigned long data) ixgb_watchdog(struct timer_list *t)
{ {
struct ixgb_adapter *adapter = (struct ixgb_adapter *)data; struct ixgb_adapter *adapter = from_timer(adapter, t, watchdog_timer);
struct net_device *netdev = adapter->netdev; struct net_device *netdev = adapter->netdev;
struct ixgb_desc_ring *txdr = &adapter->tx_ring; struct ixgb_desc_ring *txdr = &adapter->tx_ring;

View File

@ -7690,9 +7690,9 @@ static void ixgbe_sfp_link_config_subtask(struct ixgbe_adapter *adapter)
* ixgbe_service_timer - Timer Call-back * ixgbe_service_timer - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
**/ **/
static void ixgbe_service_timer(unsigned long data) static void ixgbe_service_timer(struct timer_list *t)
{ {
struct ixgbe_adapter *adapter = (struct ixgbe_adapter *)data; struct ixgbe_adapter *adapter = from_timer(adapter, t, service_timer);
unsigned long next_event_offset; unsigned long next_event_offset;
/* poll faster when waiting for link */ /* poll faster when waiting for link */
@ -10508,8 +10508,7 @@ skip_sriov:
ether_addr_copy(hw->mac.addr, hw->mac.perm_addr); ether_addr_copy(hw->mac.addr, hw->mac.perm_addr);
ixgbe_mac_set_default_filter(adapter); ixgbe_mac_set_default_filter(adapter);
setup_timer(&adapter->service_timer, &ixgbe_service_timer, timer_setup(&adapter->service_timer, ixgbe_service_timer, 0);
(unsigned long) adapter);
if (ixgbe_removed(hw->hw_addr)) { if (ixgbe_removed(hw->hw_addr)) {
err = -EIO; err = -EIO;

View File

@ -2747,9 +2747,10 @@ void ixgbevf_update_stats(struct ixgbevf_adapter *adapter)
* ixgbevf_service_timer - Timer Call-back * ixgbevf_service_timer - Timer Call-back
* @data: pointer to adapter cast into an unsigned long * @data: pointer to adapter cast into an unsigned long
**/ **/
static void ixgbevf_service_timer(unsigned long data) static void ixgbevf_service_timer(struct timer_list *t)
{ {
struct ixgbevf_adapter *adapter = (struct ixgbevf_adapter *)data; struct ixgbevf_adapter *adapter = from_timer(adapter, t,
service_timer);
/* Reset the timer */ /* Reset the timer */
mod_timer(&adapter->service_timer, (HZ * 2) + jiffies); mod_timer(&adapter->service_timer, (HZ * 2) + jiffies);
@ -4120,8 +4121,7 @@ static int ixgbevf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
goto err_sw_init; goto err_sw_init;
} }
setup_timer(&adapter->service_timer, &ixgbevf_service_timer, timer_setup(&adapter->service_timer, ixgbevf_service_timer, 0);
(unsigned long)adapter);
INIT_WORK(&adapter->service_task, ixgbevf_service_task); INIT_WORK(&adapter->service_task, ixgbevf_service_task);
set_bit(__IXGBEVF_SERVICE_INITED, &adapter->state); set_bit(__IXGBEVF_SERVICE_INITED, &adapter->state);

View File

@ -4338,11 +4338,11 @@ static void ksz_stop_timer(struct ksz_timer_info *info)
} }
static void ksz_init_timer(struct ksz_timer_info *info, int period, static void ksz_init_timer(struct ksz_timer_info *info, int period,
void (*function)(unsigned long), void *data) void (*function)(struct timer_list *))
{ {
info->max = 0; info->max = 0;
info->period = period; info->period = period;
setup_timer(&info->timer, function, (unsigned long)data); timer_setup(&info->timer, function, 0);
} }
static void ksz_update_timer(struct ksz_timer_info *info) static void ksz_update_timer(struct ksz_timer_info *info)
@ -6689,9 +6689,9 @@ static void mib_read_work(struct work_struct *work)
} }
} }
static void mib_monitor(unsigned long ptr) static void mib_monitor(struct timer_list *t)
{ {
struct dev_info *hw_priv = (struct dev_info *) ptr; struct dev_info *hw_priv = from_timer(hw_priv, t, mib_timer_info.timer);
mib_read_work(&hw_priv->mib_read); mib_read_work(&hw_priv->mib_read);
@ -6716,10 +6716,10 @@ static void mib_monitor(unsigned long ptr)
* *
* This routine is run in a kernel timer to monitor the network device. * This routine is run in a kernel timer to monitor the network device.
*/ */
static void dev_monitor(unsigned long ptr) static void dev_monitor(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) ptr; struct dev_priv *priv = from_timer(priv, t, monitor_timer_info.timer);
struct dev_priv *priv = netdev_priv(dev); struct net_device *dev = priv->mii_if.dev;
struct dev_info *hw_priv = priv->adapter; struct dev_info *hw_priv = priv->adapter;
struct ksz_hw *hw = &hw_priv->hw; struct ksz_hw *hw = &hw_priv->hw;
struct ksz_port *port = &priv->port; struct ksz_port *port = &priv->port;
@ -6789,7 +6789,7 @@ static int __init netdev_init(struct net_device *dev)
/* 500 ms timeout */ /* 500 ms timeout */
ksz_init_timer(&priv->monitor_timer_info, 500 * HZ / 1000, ksz_init_timer(&priv->monitor_timer_info, 500 * HZ / 1000,
dev_monitor, dev); dev_monitor);
/* 500 ms timeout */ /* 500 ms timeout */
dev->watchdog_timeo = HZ / 2; dev->watchdog_timeo = HZ / 2;
@ -7065,7 +7065,7 @@ static int pcidev_init(struct pci_dev *pdev, const struct pci_device_id *id)
/* 500 ms timeout */ /* 500 ms timeout */
ksz_init_timer(&hw_priv->mib_timer_info, 500 * HZ / 1000, ksz_init_timer(&hw_priv->mib_timer_info, 500 * HZ / 1000,
mib_monitor, hw_priv); mib_monitor);
for (i = 0; i < hw->dev_count; i++) { for (i = 0; i < hw->dev_count; i++) {
dev = alloc_etherdev(sizeof(struct dev_priv)); dev = alloc_etherdev(sizeof(struct dev_priv));

View File

@ -337,12 +337,6 @@ static const char ethtool_driver_stats_keys[][ETH_GSTRING_LEN] = {
#define S2IO_TEST_LEN ARRAY_SIZE(s2io_gstrings) #define S2IO_TEST_LEN ARRAY_SIZE(s2io_gstrings)
#define S2IO_STRINGS_LEN (S2IO_TEST_LEN * ETH_GSTRING_LEN) #define S2IO_STRINGS_LEN (S2IO_TEST_LEN * ETH_GSTRING_LEN)
#define S2IO_TIMER_CONF(timer, handle, arg, exp) \
init_timer(&timer); \
timer.function = handle; \
timer.data = (unsigned long)arg; \
mod_timer(&timer, (jiffies + exp)) \
/* copy mac addr to def_mac_addr array */ /* copy mac addr to def_mac_addr array */
static void do_s2io_copy_mac_addr(struct s2io_nic *sp, int offset, u64 mac_addr) static void do_s2io_copy_mac_addr(struct s2io_nic *sp, int offset, u64 mac_addr)
{ {
@ -4193,9 +4187,9 @@ pci_map_failed:
} }
static void static void
s2io_alarm_handle(unsigned long data) s2io_alarm_handle(struct timer_list *t)
{ {
struct s2io_nic *sp = (struct s2io_nic *)data; struct s2io_nic *sp = from_timer(sp, t, alarm_timer);
struct net_device *dev = sp->dev; struct net_device *dev = sp->dev;
s2io_handle_errors(dev); s2io_handle_errors(dev);
@ -7186,7 +7180,8 @@ static int s2io_card_up(struct s2io_nic *sp)
return -ENODEV; return -ENODEV;
} }
S2IO_TIMER_CONF(sp->alarm_timer, s2io_alarm_handle, sp, (HZ/2)); timer_setup(&sp->alarm_timer, s2io_alarm_handle, 0);
mod_timer(&sp->alarm_timer, jiffies + HZ / 2);
set_bit(__S2IO_STATE_CARD_UP, &sp->state); set_bit(__S2IO_STATE_CARD_UP, &sp->state);

View File

@ -1094,7 +1094,7 @@ static int s2io_poll_msix(struct napi_struct *napi, int budget);
static int s2io_poll_inta(struct napi_struct *napi, int budget); static int s2io_poll_inta(struct napi_struct *napi, int budget);
static void s2io_init_pci(struct s2io_nic * sp); static void s2io_init_pci(struct s2io_nic * sp);
static int do_s2io_prog_unicast(struct net_device *dev, u8 *addr); static int do_s2io_prog_unicast(struct net_device *dev, u8 *addr);
static void s2io_alarm_handle(unsigned long data); static void s2io_alarm_handle(struct timer_list *t);
static irqreturn_t static irqreturn_t
s2io_msix_ring_handle(int irq, void *dev_id); s2io_msix_ring_handle(int irq, void *dev_id);
static irqreturn_t static irqreturn_t

View File

@ -2597,9 +2597,9 @@ INTA_MODE:
return VXGE_HW_OK; return VXGE_HW_OK;
} }
static void vxge_poll_vp_reset(unsigned long data) static void vxge_poll_vp_reset(struct timer_list *t)
{ {
struct vxgedev *vdev = (struct vxgedev *)data; struct vxgedev *vdev = from_timer(vdev, t, vp_reset_timer);
int i, j = 0; int i, j = 0;
for (i = 0; i < vdev->no_of_vpath; i++) { for (i = 0; i < vdev->no_of_vpath; i++) {
@ -2616,9 +2616,9 @@ static void vxge_poll_vp_reset(unsigned long data)
mod_timer(&vdev->vp_reset_timer, jiffies + HZ / 2); mod_timer(&vdev->vp_reset_timer, jiffies + HZ / 2);
} }
static void vxge_poll_vp_lockup(unsigned long data) static void vxge_poll_vp_lockup(struct timer_list *t)
{ {
struct vxgedev *vdev = (struct vxgedev *)data; struct vxgedev *vdev = from_timer(vdev, t, vp_lockup_timer);
enum vxge_hw_status status = VXGE_HW_OK; enum vxge_hw_status status = VXGE_HW_OK;
struct vxge_vpath *vpath; struct vxge_vpath *vpath;
struct vxge_ring *ring; struct vxge_ring *ring;
@ -2858,12 +2858,12 @@ static int vxge_open(struct net_device *dev)
vdev->config.rx_pause_enable); vdev->config.rx_pause_enable);
if (vdev->vp_reset_timer.function == NULL) if (vdev->vp_reset_timer.function == NULL)
vxge_os_timer(&vdev->vp_reset_timer, vxge_poll_vp_reset, vdev, vxge_os_timer(&vdev->vp_reset_timer, vxge_poll_vp_reset,
HZ / 2); HZ / 2);
/* There is no need to check for RxD leak and RxD lookup on Titan1A */ /* There is no need to check for RxD leak and RxD lookup on Titan1A */
if (vdev->titan1 && vdev->vp_lockup_timer.function == NULL) if (vdev->titan1 && vdev->vp_lockup_timer.function == NULL)
vxge_os_timer(&vdev->vp_lockup_timer, vxge_poll_vp_lockup, vdev, vxge_os_timer(&vdev->vp_lockup_timer, vxge_poll_vp_lockup,
HZ / 2); HZ / 2);
set_bit(__VXGE_STATE_CARD_UP, &vdev->state); set_bit(__VXGE_STATE_CARD_UP, &vdev->state);

View File

@ -417,12 +417,10 @@ struct vxge_tx_priv {
module_param(p, int, 0) module_param(p, int, 0)
static inline static inline
void vxge_os_timer(struct timer_list *timer, void (*func)(unsigned long data), void vxge_os_timer(struct timer_list *timer, void (*func)(struct timer_list *),
struct vxgedev *vdev, unsigned long timeout) unsigned long timeout)
{ {
init_timer(timer); timer_setup(timer, func, 0);
timer->function = func;
timer->data = (unsigned long)vdev;
mod_timer(timer, jiffies + timeout); mod_timer(timer, jiffies + timeout);
} }

View File

@ -1884,10 +1884,9 @@ packet_dropped:
} }
/* If rx bufs are exhausted called after 50ms to attempt to refresh */ /* If rx bufs are exhausted called after 50ms to attempt to refresh */
static void nv_do_rx_refill(unsigned long data) static void nv_do_rx_refill(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct fe_priv *np = from_timer(np, t, oom_kick);
struct fe_priv *np = netdev_priv(dev);
/* Just reschedule NAPI rx processing */ /* Just reschedule NAPI rx processing */
napi_schedule(&np->napi); napi_schedule(&np->napi);
@ -4065,10 +4064,10 @@ static void nv_free_irq(struct net_device *dev)
} }
} }
static void nv_do_nic_poll(unsigned long data) static void nv_do_nic_poll(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct fe_priv *np = from_timer(np, t, nic_poll);
struct fe_priv *np = netdev_priv(dev); struct net_device *dev = np->dev;
u8 __iomem *base = get_hwbase(dev); u8 __iomem *base = get_hwbase(dev);
u32 mask = 0; u32 mask = 0;
unsigned long flags; unsigned long flags;
@ -4176,16 +4175,18 @@ static void nv_do_nic_poll(unsigned long data)
#ifdef CONFIG_NET_POLL_CONTROLLER #ifdef CONFIG_NET_POLL_CONTROLLER
static void nv_poll_controller(struct net_device *dev) static void nv_poll_controller(struct net_device *dev)
{ {
nv_do_nic_poll((unsigned long) dev); struct fe_priv *np = netdev_priv(dev);
nv_do_nic_poll(&np->nic_poll);
} }
#endif #endif
static void nv_do_stats_poll(unsigned long data) static void nv_do_stats_poll(struct timer_list *t)
__acquires(&netdev_priv(dev)->hwstats_lock) __acquires(&netdev_priv(dev)->hwstats_lock)
__releases(&netdev_priv(dev)->hwstats_lock) __releases(&netdev_priv(dev)->hwstats_lock)
{ {
struct net_device *dev = (struct net_device *) data; struct fe_priv *np = from_timer(np, t, stats_poll);
struct fe_priv *np = netdev_priv(dev); struct net_device *dev = np->dev;
/* If lock is currently taken, the stats are being refreshed /* If lock is currently taken, the stats are being refreshed
* and hence fresh enough */ * and hence fresh enough */
@ -5631,10 +5632,9 @@ static int nv_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
u64_stats_init(&np->swstats_rx_syncp); u64_stats_init(&np->swstats_rx_syncp);
u64_stats_init(&np->swstats_tx_syncp); u64_stats_init(&np->swstats_tx_syncp);
setup_timer(&np->oom_kick, nv_do_rx_refill, (unsigned long)dev); timer_setup(&np->oom_kick, nv_do_rx_refill, 0);
setup_timer(&np->nic_poll, nv_do_nic_poll, (unsigned long)dev); timer_setup(&np->nic_poll, nv_do_nic_poll, 0);
setup_deferrable_timer(&np->stats_poll, nv_do_stats_poll, timer_setup(&np->stats_poll, nv_do_stats_poll, TIMER_DEFERRABLE);
(unsigned long)dev);
err = pci_enable_device(pci_dev); err = pci_enable_device(pci_dev);
if (err) if (err)

View File

@ -170,9 +170,11 @@ ether3_setbuffer(struct net_device *dev, buffer_rw_t read, int start)
/* /*
* Switch LED off... * Switch LED off...
*/ */
static void ether3_ledoff(unsigned long data) static void ether3_ledoff(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)data; struct dev_priv *private = from_timer(priv, t, timer);
struct net_device *dev = private->dev;
ether3_outw(priv(dev)->regs.config2 |= CFG2_CTRLO, REG_CONFIG2); ether3_outw(priv(dev)->regs.config2 |= CFG2_CTRLO, REG_CONFIG2);
} }
@ -183,8 +185,6 @@ static inline void ether3_ledon(struct net_device *dev)
{ {
del_timer(&priv(dev)->timer); del_timer(&priv(dev)->timer);
priv(dev)->timer.expires = jiffies + HZ / 50; /* leave on for 1/50th second */ priv(dev)->timer.expires = jiffies + HZ / 50; /* leave on for 1/50th second */
priv(dev)->timer.data = (unsigned long)dev;
priv(dev)->timer.function = ether3_ledoff;
add_timer(&priv(dev)->timer); add_timer(&priv(dev)->timer);
if (priv(dev)->regs.config2 & CFG2_CTRLO) if (priv(dev)->regs.config2 & CFG2_CTRLO)
ether3_outw(priv(dev)->regs.config2 &= ~CFG2_CTRLO, REG_CONFIG2); ether3_outw(priv(dev)->regs.config2 &= ~CFG2_CTRLO, REG_CONFIG2);
@ -783,7 +783,8 @@ ether3_probe(struct expansion_card *ec, const struct ecard_id *id)
ether3_addr(dev->dev_addr, ec); ether3_addr(dev->dev_addr, ec);
init_timer(&priv(dev)->timer); priv(dev)->dev = dev;
timer_setup(&priv(dev)->timer, ether3_ledoff, 0);
/* Reset card... /* Reset card...
*/ */

View File

@ -165,6 +165,7 @@ struct dev_priv {
unsigned char tx_tail; /* buffer nr of transmitting packet */ unsigned char tx_tail; /* buffer nr of transmitting packet */
unsigned int rx_head; /* address to fetch next packet from */ unsigned int rx_head; /* address to fetch next packet from */
struct timer_list timer; struct timer_list timer;
net_device *dev;
int broken; /* 0 = ok, 1 = something went wrong */ int broken; /* 0 = ok, 1 = something went wrong */
}; };

View File

@ -764,9 +764,9 @@ static inline void ioc3_setup_duplex(struct ioc3_private *ip)
ioc3_w_emcr(ip->emcr); ioc3_w_emcr(ip->emcr);
} }
static void ioc3_timer(unsigned long data) static void ioc3_timer(struct timer_list *t)
{ {
struct ioc3_private *ip = (struct ioc3_private *) data; struct ioc3_private *ip = from_timer(ip, t, ioc3_timer);
/* Print the link status if it has changed */ /* Print the link status if it has changed */
mii_check_media(&ip->mii, 1, 0); mii_check_media(&ip->mii, 1, 0);
@ -818,8 +818,6 @@ out:
static void ioc3_mii_start(struct ioc3_private *ip) static void ioc3_mii_start(struct ioc3_private *ip)
{ {
ip->ioc3_timer.expires = jiffies + (12 * HZ)/10; /* 1.2 sec. */ ip->ioc3_timer.expires = jiffies + (12 * HZ)/10; /* 1.2 sec. */
ip->ioc3_timer.data = (unsigned long) ip;
ip->ioc3_timer.function = ioc3_timer;
add_timer(&ip->ioc3_timer); add_timer(&ip->ioc3_timer);
} }
@ -1291,7 +1289,7 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
#endif #endif
spin_lock_init(&ip->ioc3_lock); spin_lock_init(&ip->ioc3_lock);
init_timer(&ip->ioc3_timer); timer_setup(&ip->ioc3_timer, ioc3_timer, 0);
ioc3_stop(ip); ioc3_stop(ip);
ioc3_init(dev); ioc3_init(dev);

View File

@ -118,10 +118,9 @@ int tse_pcs_init(void __iomem *base, struct tse_pcs *pcs)
return ret; return ret;
} }
static void pcs_link_timer_callback(unsigned long data) static void pcs_link_timer_callback(struct tse_pcs *pcs)
{ {
u16 val = 0; u16 val = 0;
struct tse_pcs *pcs = (struct tse_pcs *)data;
void __iomem *tse_pcs_base = pcs->tse_pcs_base; void __iomem *tse_pcs_base = pcs->tse_pcs_base;
void __iomem *sgmii_adapter_base = pcs->sgmii_adapter_base; void __iomem *sgmii_adapter_base = pcs->sgmii_adapter_base;
@ -138,12 +137,11 @@ static void pcs_link_timer_callback(unsigned long data)
} }
} }
static void auto_nego_timer_callback(unsigned long data) static void auto_nego_timer_callback(struct tse_pcs *pcs)
{ {
u16 val = 0; u16 val = 0;
u16 speed = 0; u16 speed = 0;
u16 duplex = 0; u16 duplex = 0;
struct tse_pcs *pcs = (struct tse_pcs *)data;
void __iomem *tse_pcs_base = pcs->tse_pcs_base; void __iomem *tse_pcs_base = pcs->tse_pcs_base;
void __iomem *sgmii_adapter_base = pcs->sgmii_adapter_base; void __iomem *sgmii_adapter_base = pcs->sgmii_adapter_base;
@ -201,14 +199,14 @@ static void auto_nego_timer_callback(unsigned long data)
} }
} }
static void aneg_link_timer_callback(unsigned long data) static void aneg_link_timer_callback(struct timer_list *t)
{ {
struct tse_pcs *pcs = (struct tse_pcs *)data; struct tse_pcs *pcs = from_timer(pcs, t, aneg_link_timer);
if (pcs->autoneg == AUTONEG_ENABLE) if (pcs->autoneg == AUTONEG_ENABLE)
auto_nego_timer_callback(data); auto_nego_timer_callback(pcs);
else if (pcs->autoneg == AUTONEG_DISABLE) else if (pcs->autoneg == AUTONEG_DISABLE)
pcs_link_timer_callback(data); pcs_link_timer_callback(pcs);
} }
void tse_pcs_fix_mac_speed(struct tse_pcs *pcs, struct phy_device *phy_dev, void tse_pcs_fix_mac_speed(struct tse_pcs *pcs, struct phy_device *phy_dev,
@ -237,8 +235,8 @@ void tse_pcs_fix_mac_speed(struct tse_pcs *pcs, struct phy_device *phy_dev,
tse_pcs_reset(tse_pcs_base, pcs); tse_pcs_reset(tse_pcs_base, pcs);
setup_timer(&pcs->aneg_link_timer, timer_setup(&pcs->aneg_link_timer, aneg_link_timer_callback,
aneg_link_timer_callback, (unsigned long)pcs); 0);
mod_timer(&pcs->aneg_link_timer, jiffies + mod_timer(&pcs->aneg_link_timer, jiffies +
msecs_to_jiffies(AUTONEGO_LINK_TIMER)); msecs_to_jiffies(AUTONEGO_LINK_TIMER));
} else if (phy_dev->autoneg == AUTONEG_DISABLE) { } else if (phy_dev->autoneg == AUTONEG_DISABLE) {
@ -270,8 +268,8 @@ void tse_pcs_fix_mac_speed(struct tse_pcs *pcs, struct phy_device *phy_dev,
tse_pcs_reset(tse_pcs_base, pcs); tse_pcs_reset(tse_pcs_base, pcs);
setup_timer(&pcs->aneg_link_timer, timer_setup(&pcs->aneg_link_timer, aneg_link_timer_callback,
aneg_link_timer_callback, (unsigned long)pcs); 0);
mod_timer(&pcs->aneg_link_timer, jiffies + mod_timer(&pcs->aneg_link_timer, jiffies +
msecs_to_jiffies(AUTONEGO_LINK_TIMER)); msecs_to_jiffies(AUTONEGO_LINK_TIMER));
} }

View File

@ -4079,9 +4079,9 @@ done:
#endif #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; int mask, pending = 0, reset = 0;
unsigned long flags; unsigned long flags;
@ -5039,7 +5039,8 @@ static int cas_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
spin_lock_init(&cp->stat_lock[N_TX_RINGS]); spin_lock_init(&cp->stat_lock[N_TX_RINGS]);
mutex_init(&cp->pm_mutex); 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 #if 1
/* Just in case the implementation of atomic operations /* Just in case the implementation of atomic operations
* change so that an explicit initialization is necessary. * change so that an explicit initialization is necessary.

View File

@ -363,8 +363,7 @@ static int vsw_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
list_add_rcu(&port->list, &vp->port_list); list_add_rcu(&port->list, &vp->port_list);
spin_unlock_irqrestore(&vp->lock, flags); spin_unlock_irqrestore(&vp->lock, flags);
setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common, timer_setup(&port->clean_timer, sunvnet_clean_timer_expire_common, 0);
(unsigned long)port);
err = register_netdev(dev); err = register_netdev(dev);
if (err) { if (err) {

View File

@ -2221,9 +2221,9 @@ static int niu_link_status(struct niu *np, int *link_up_p)
return 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; unsigned long off;
int err, link_up; int err, link_up;
@ -6123,7 +6123,7 @@ static int niu_open(struct net_device *dev)
err = niu_init_hw(np); err = niu_init_hw(np);
if (!err) { if (!err) {
setup_timer(&np->timer, niu_timer, (unsigned long)np); timer_setup(&np->timer, niu_timer, 0);
np->timer.expires = jiffies + HZ; np->timer.expires = jiffies + HZ;
err = niu_enable_interrupts(np, 1); err = niu_enable_interrupts(np, 1);
@ -6773,10 +6773,8 @@ static int niu_change_mtu(struct net_device *dev, int new_mtu)
err = niu_init_hw(np); err = niu_init_hw(np);
if (!err) { if (!err) {
init_timer(&np->timer); timer_setup(&np->timer, niu_timer, 0);
np->timer.expires = jiffies + HZ; np->timer.expires = jiffies + HZ;
np->timer.data = (unsigned long) np;
np->timer.function = niu_timer;
err = niu_enable_interrupts(np, 1); err = niu_enable_interrupts(np, 1);
if (err) if (err)

View File

@ -523,9 +523,9 @@ static int try_next_permutation(struct bigmac *bp, void __iomem *tregs)
return -1; 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; void __iomem *tregs = bp->tregs;
int restart_timer = 0; int restart_timer = 0;
@ -613,8 +613,6 @@ static void bigmac_begin_auto_negotiation(struct bigmac *bp)
bp->timer_state = ltrywait; bp->timer_state = ltrywait;
bp->timer_ticks = 0; bp->timer_ticks = 0;
bp->bigmac_timer.expires = jiffies + (12 * HZ) / 10; 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); add_timer(&bp->bigmac_timer);
} }
@ -921,7 +919,7 @@ static int bigmac_open(struct net_device *dev)
printk(KERN_ERR "BIGMAC: Can't order irq %d to go.\n", dev->irq); printk(KERN_ERR "BIGMAC: Can't order irq %d to go.\n", dev->irq);
return ret; return ret;
} }
init_timer(&bp->bigmac_timer); timer_setup(&bp->bigmac_timer, bigmac_timer, 0);
ret = bigmac_init_hw(bp, 0); ret = bigmac_init_hw(bp, 0);
if (ret) if (ret)
free_irq(dev->irq, bp); free_irq(dev->irq, bp);
@ -1172,7 +1170,7 @@ static int bigmac_ether_init(struct platform_device *op,
"board-version", 1); "board-version", 1);
/* Init auto-negotiation timer state. */ /* Init auto-negotiation timer state. */
init_timer(&bp->bigmac_timer); timer_setup(&bp->bigmac_timer, bigmac_timer, 0);
bp->timer_state = asleep; bp->timer_state = asleep;
bp->timer_ticks = 0; bp->timer_ticks = 0;

View File

@ -1496,9 +1496,9 @@ static int gem_mdio_link_not_up(struct gem *gp)
} }
} }
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; struct net_device *dev = gp->dev;
int restart_aneg = 0; int restart_aneg = 0;
@ -2910,7 +2910,7 @@ static int gem_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
gp->msg_enable = DEFAULT_MSG; 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); INIT_WORK(&gp->reset_task, gem_reset_task);

View File

@ -685,9 +685,9 @@ static int is_lucent_phy(struct happy_meal *hp)
return ret; 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; void __iomem *tregs = hp->tcvregs;
int restart_timer = 0; int restart_timer = 0;
@ -1413,8 +1413,6 @@ force_link:
hp->timer_ticks = 0; hp->timer_ticks = 0;
hp->happy_timer.expires = jiffies + (12 * HZ)/10; /* 1.2 sec. */ 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); add_timer(&hp->happy_timer);
} }
@ -2819,7 +2817,7 @@ static int happy_meal_sbus_probe_one(struct platform_device *op, int is_qfe)
hp->timer_state = asleep; hp->timer_state = asleep;
hp->timer_ticks = 0; hp->timer_ticks = 0;
init_timer(&hp->happy_timer); timer_setup(&hp->happy_timer, happy_meal_timer, 0);
hp->dev = dev; hp->dev = dev;
dev->netdev_ops = &hme_netdev_ops; dev->netdev_ops = &hme_netdev_ops;
@ -3133,7 +3131,7 @@ static int happy_meal_pci_probe(struct pci_dev *pdev,
hp->timer_state = asleep; hp->timer_state = asleep;
hp->timer_ticks = 0; hp->timer_ticks = 0;
init_timer(&hp->happy_timer); timer_setup(&hp->happy_timer, happy_meal_timer, 0);
hp->irq = pdev->irq; hp->irq = pdev->irq;
hp->dev = dev; hp->dev = dev;

View File

@ -492,8 +492,7 @@ static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
pr_info("%s: PORT ( remote-mac %pM%s )\n", pr_info("%s: PORT ( remote-mac %pM%s )\n",
vp->dev->name, port->raddr, switch_port ? " switch-port" : ""); vp->dev->name, port->raddr, switch_port ? " switch-port" : "");
setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common, timer_setup(&port->clean_timer, sunvnet_clean_timer_expire_common, 0);
(unsigned long)port);
napi_enable(&port->napi); napi_enable(&port->napi);
vio_port_up(&port->vio); vio_port_up(&port->vio);

View File

@ -1040,9 +1040,9 @@ static inline void vnet_free_skbs(struct sk_buff *skb)
} }
} }
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; struct sk_buff *freeskbs;
unsigned pending; unsigned pending;

View File

@ -129,7 +129,7 @@ struct vnet {
((__port)->vsw ? (__port)->dev : (__port)->vp->dev) ((__port)->vsw ? (__port)->dev : (__port)->vp->dev)
/* Common funcs */ /* 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_open_common(struct net_device *dev);
int sunvnet_close_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); void sunvnet_set_rx_mode_common(struct net_device *dev, struct vnet *vp);

View File

@ -172,7 +172,8 @@ static u32 tlan_handle_tx_eoc(struct net_device *, u16);
static u32 tlan_handle_status_check(struct net_device *, u16); static u32 tlan_handle_status_check(struct net_device *, u16);
static u32 tlan_handle_rx_eoc(struct net_device *, u16); static u32 tlan_handle_rx_eoc(struct net_device *, u16);
static void tlan_timer(unsigned long); static void tlan_timer(struct timer_list *t);
static void tlan_phy_monitor(struct timer_list *t);
static void tlan_reset_lists(struct net_device *); static void tlan_reset_lists(struct net_device *);
static void tlan_free_lists(struct net_device *); static void tlan_free_lists(struct net_device *);
@ -190,7 +191,6 @@ static void tlan_phy_power_up(struct net_device *);
static void tlan_phy_reset(struct net_device *); static void tlan_phy_reset(struct net_device *);
static void tlan_phy_start_link(struct net_device *); static void tlan_phy_start_link(struct net_device *);
static void tlan_phy_finish_auto_neg(struct net_device *); static void tlan_phy_finish_auto_neg(struct net_device *);
static void tlan_phy_monitor(unsigned long);
/* /*
static int tlan_phy_nop(struct net_device *); static int tlan_phy_nop(struct net_device *);
@ -254,11 +254,10 @@ tlan_set_timer(struct net_device *dev, u32 ticks, u32 type)
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
return; return;
} }
priv->timer.function = tlan_timer; priv->timer.function = (TIMER_FUNC_TYPE)tlan_timer;
if (!in_irq()) if (!in_irq())
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
priv->timer.data = (unsigned long) dev;
priv->timer_set_at = jiffies; priv->timer_set_at = jiffies;
priv->timer_type = type; priv->timer_type = type;
mod_timer(&priv->timer, jiffies + ticks); mod_timer(&priv->timer, jiffies + ticks);
@ -926,8 +925,8 @@ static int tlan_open(struct net_device *dev)
return err; return err;
} }
init_timer(&priv->timer); timer_setup(&priv->timer, NULL, 0);
init_timer(&priv->media_timer); timer_setup(&priv->media_timer, tlan_phy_monitor, 0);
tlan_start(dev); tlan_start(dev);
@ -1426,8 +1425,7 @@ static u32 tlan_handle_tx_eof(struct net_device *dev, u16 host_int)
tlan_dio_write8(dev->base_addr, tlan_dio_write8(dev->base_addr,
TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT); TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
if (priv->timer.function == NULL) { if (priv->timer.function == NULL) {
priv->timer.function = tlan_timer; priv->timer.function = (TIMER_FUNC_TYPE)tlan_timer;
priv->timer.data = (unsigned long) dev;
priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY; priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
priv->timer_set_at = jiffies; priv->timer_set_at = jiffies;
priv->timer_type = TLAN_TIMER_ACTIVITY; priv->timer_type = TLAN_TIMER_ACTIVITY;
@ -1578,8 +1576,7 @@ drop_and_reuse:
tlan_dio_write8(dev->base_addr, tlan_dio_write8(dev->base_addr,
TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT); TLAN_LED_REG, TLAN_LED_LINK | TLAN_LED_ACT);
if (priv->timer.function == NULL) { if (priv->timer.function == NULL) {
priv->timer.function = tlan_timer; priv->timer.function = (TIMER_FUNC_TYPE)tlan_timer;
priv->timer.data = (unsigned long) dev;
priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY; priv->timer.expires = jiffies + TLAN_TIMER_ACT_DELAY;
priv->timer_set_at = jiffies; priv->timer_set_at = jiffies;
priv->timer_type = TLAN_TIMER_ACTIVITY; priv->timer_type = TLAN_TIMER_ACTIVITY;
@ -1836,10 +1833,10 @@ ThunderLAN driver timer function
* *
**************************************************************/ **************************************************************/
static void tlan_timer(unsigned long data) static void tlan_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct tlan_priv *priv = from_timer(priv, t, timer);
struct tlan_priv *priv = netdev_priv(dev); struct net_device *dev = priv->dev;
u32 elapsed; u32 elapsed;
unsigned long flags = 0; unsigned long flags = 0;
@ -1872,7 +1869,6 @@ static void tlan_timer(unsigned long data)
tlan_dio_write8(dev->base_addr, tlan_dio_write8(dev->base_addr,
TLAN_LED_REG, TLAN_LED_LINK); TLAN_LED_REG, TLAN_LED_LINK);
} else { } else {
priv->timer.function = tlan_timer;
priv->timer.expires = priv->timer_set_at priv->timer.expires = priv->timer_set_at
+ TLAN_TIMER_ACT_DELAY; + TLAN_TIMER_ACT_DELAY;
spin_unlock_irqrestore(&priv->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
@ -2317,8 +2313,6 @@ tlan_finish_reset(struct net_device *dev)
} else } else
netdev_info(dev, "Link active\n"); netdev_info(dev, "Link active\n");
/* Enabling link beat monitoring */ /* Enabling link beat monitoring */
priv->media_timer.function = tlan_phy_monitor;
priv->media_timer.data = (unsigned long) dev;
priv->media_timer.expires = jiffies + HZ; priv->media_timer.expires = jiffies + HZ;
add_timer(&priv->media_timer); add_timer(&priv->media_timer);
} }
@ -2763,10 +2757,10 @@ static void tlan_phy_finish_auto_neg(struct net_device *dev)
* *
*******************************************************************/ *******************************************************************/
static void tlan_phy_monitor(unsigned long data) static void tlan_phy_monitor(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *) data; struct tlan_priv *priv = from_timer(priv, t, media_timer);
struct tlan_priv *priv = netdev_priv(dev); struct net_device *dev = priv->dev;
u16 phy; u16 phy;
u16 phy_status; u16 phy_status;

View File

@ -136,9 +136,9 @@ static int encode_sixpack(unsigned char *, unsigned char *, int, unsigned char);
* Note that in case of DAMA operation, the data is not sent here. * Note that in case of DAMA operation, the data is not sent here.
*/ */
static void sp_xmit_on_air(unsigned long channel) static void sp_xmit_on_air(struct timer_list *t)
{ {
struct sixpack *sp = (struct sixpack *) channel; struct sixpack *sp = from_timer(sp, t, tx_t);
int actual, when = sp->slottime; int actual, when = sp->slottime;
static unsigned char random; static unsigned char random;
@ -229,7 +229,7 @@ static void sp_encaps(struct sixpack *sp, unsigned char *icp, int len)
sp->xleft = count; sp->xleft = count;
sp->xhead = sp->xbuff; sp->xhead = sp->xbuff;
sp->status2 = count; sp->status2 = count;
sp_xmit_on_air((unsigned long)sp); sp_xmit_on_air(&sp->tx_t);
} }
return; return;
@ -500,9 +500,9 @@ static inline void tnc_set_sync_state(struct sixpack *sp, int new_tnc_state)
__tnc_set_sync_state(sp, new_tnc_state); __tnc_set_sync_state(sp, new_tnc_state);
} }
static void resync_tnc(unsigned long channel) static void resync_tnc(struct timer_list *t)
{ {
struct sixpack *sp = (struct sixpack *) channel; struct sixpack *sp = from_timer(sp, t, resync_t);
static char resync_cmd = 0xe8; static char resync_cmd = 0xe8;
/* clear any data that might have been received */ /* clear any data that might have been received */
@ -526,8 +526,6 @@ static void resync_tnc(unsigned long channel)
/* Start resync timer again -- the TNC might be still absent */ /* Start resync timer again -- the TNC might be still absent */
del_timer(&sp->resync_t); del_timer(&sp->resync_t);
sp->resync_t.data = (unsigned long) sp;
sp->resync_t.function = resync_tnc;
sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT; sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
add_timer(&sp->resync_t); add_timer(&sp->resync_t);
} }
@ -541,8 +539,6 @@ static inline int tnc_init(struct sixpack *sp)
sp->tty->ops->write(sp->tty, &inbyte, 1); sp->tty->ops->write(sp->tty, &inbyte, 1);
del_timer(&sp->resync_t); del_timer(&sp->resync_t);
sp->resync_t.data = (unsigned long) sp;
sp->resync_t.function = resync_tnc;
sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT; sp->resync_t.expires = jiffies + SIXP_RESYNC_TIMEOUT;
add_timer(&sp->resync_t); add_timer(&sp->resync_t);
@ -623,9 +619,9 @@ static int sixpack_open(struct tty_struct *tty)
netif_start_queue(dev); netif_start_queue(dev);
setup_timer(&sp->tx_t, sp_xmit_on_air, (unsigned long)sp); timer_setup(&sp->tx_t, sp_xmit_on_air, 0);
init_timer(&sp->resync_t); timer_setup(&sp->resync_t, resync_tnc, 0);
spin_unlock_bh(&sp->lock); spin_unlock_bh(&sp->lock);
@ -926,8 +922,6 @@ static void decode_prio_command(struct sixpack *sp, unsigned char cmd)
if (sp->tnc_state == TNC_IN_SYNC) { if (sp->tnc_state == TNC_IN_SYNC) {
del_timer(&sp->resync_t); del_timer(&sp->resync_t);
sp->resync_t.data = (unsigned long) sp;
sp->resync_t.function = resync_tnc;
sp->resync_t.expires = jiffies + SIXP_INIT_RESYNC_TIMEOUT; sp->resync_t.expires = jiffies + SIXP_INIT_RESYNC_TIMEOUT;
add_timer(&sp->resync_t); add_timer(&sp->resync_t);
} }

View File

@ -185,14 +185,15 @@
static const char banner[] __initconst = KERN_INFO \ static const char banner[] __initconst = KERN_INFO \
"AX.25: Z8530 SCC driver version "VERSION".dl1bke\n"; "AX.25: Z8530 SCC driver version "VERSION".dl1bke\n";
static void t_dwait(unsigned long); static void t_dwait(struct timer_list *t);
static void t_txdelay(unsigned long); static void t_txdelay(struct timer_list *t);
static void t_tail(unsigned long); static void t_tail(struct timer_list *t);
static void t_busy(unsigned long); static void t_busy(struct timer_list *);
static void t_maxkeyup(unsigned long); static void t_maxkeyup(struct timer_list *);
static void t_idle(unsigned long); static void t_idle(struct timer_list *t);
static void scc_tx_done(struct scc_channel *); static void scc_tx_done(struct scc_channel *);
static void scc_start_tx_timer(struct scc_channel *, void (*)(unsigned long), unsigned long); static void scc_start_tx_timer(struct scc_channel *,
void (*)(struct timer_list *), unsigned long);
static void scc_start_maxkeyup(struct scc_channel *); static void scc_start_maxkeyup(struct scc_channel *);
static void scc_start_defer(struct scc_channel *); static void scc_start_defer(struct scc_channel *);
@ -992,24 +993,27 @@ static void scc_key_trx(struct scc_channel *scc, char tx)
/* ----> SCC timer interrupt handler and friends. <---- */ /* ----> SCC timer interrupt handler and friends. <---- */
static void __scc_start_tx_timer(struct scc_channel *scc, void (*handler)(unsigned long), unsigned long when) static void __scc_start_tx_timer(struct scc_channel *scc,
void (*handler)(struct timer_list *t),
unsigned long when)
{ {
del_timer(&scc->tx_t); del_timer(&scc->tx_t);
if (when == 0) if (when == 0)
{ {
handler((unsigned long) scc); handler(&scc->tx_t);
} else } else
if (when != TIMER_OFF) if (when != TIMER_OFF)
{ {
scc->tx_t.data = (unsigned long) scc; scc->tx_t.function = (TIMER_FUNC_TYPE)handler;
scc->tx_t.function = handler;
scc->tx_t.expires = jiffies + (when*HZ)/100; scc->tx_t.expires = jiffies + (when*HZ)/100;
add_timer(&scc->tx_t); add_timer(&scc->tx_t);
} }
} }
static void scc_start_tx_timer(struct scc_channel *scc, void (*handler)(unsigned long), unsigned long when) static void scc_start_tx_timer(struct scc_channel *scc,
void (*handler)(struct timer_list *t),
unsigned long when)
{ {
unsigned long flags; unsigned long flags;
@ -1027,8 +1031,7 @@ static void scc_start_defer(struct scc_channel *scc)
if (scc->kiss.maxdefer != 0 && scc->kiss.maxdefer != TIMER_OFF) if (scc->kiss.maxdefer != 0 && scc->kiss.maxdefer != TIMER_OFF)
{ {
scc->tx_wdog.data = (unsigned long) scc; scc->tx_wdog.function = (TIMER_FUNC_TYPE)t_busy;
scc->tx_wdog.function = t_busy;
scc->tx_wdog.expires = jiffies + HZ*scc->kiss.maxdefer; scc->tx_wdog.expires = jiffies + HZ*scc->kiss.maxdefer;
add_timer(&scc->tx_wdog); add_timer(&scc->tx_wdog);
} }
@ -1044,8 +1047,7 @@ static void scc_start_maxkeyup(struct scc_channel *scc)
if (scc->kiss.maxkeyup != 0 && scc->kiss.maxkeyup != TIMER_OFF) if (scc->kiss.maxkeyup != 0 && scc->kiss.maxkeyup != TIMER_OFF)
{ {
scc->tx_wdog.data = (unsigned long) scc; scc->tx_wdog.function = (TIMER_FUNC_TYPE)t_maxkeyup;
scc->tx_wdog.function = t_maxkeyup;
scc->tx_wdog.expires = jiffies + HZ*scc->kiss.maxkeyup; scc->tx_wdog.expires = jiffies + HZ*scc->kiss.maxkeyup;
add_timer(&scc->tx_wdog); add_timer(&scc->tx_wdog);
} }
@ -1121,9 +1123,9 @@ static inline int is_grouped(struct scc_channel *scc)
* fulldup == 2: mintime expired, reset status or key trx and start txdelay * fulldup == 2: mintime expired, reset status or key trx and start txdelay
*/ */
static void t_dwait(unsigned long channel) static void t_dwait(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_t);
if (scc->stat.tx_state == TXS_WAIT) /* maxkeyup or idle timeout */ if (scc->stat.tx_state == TXS_WAIT) /* maxkeyup or idle timeout */
{ {
@ -1163,9 +1165,9 @@ static void t_dwait(unsigned long channel)
* kick transmission by a fake scc_txint(scc), start 'maxkeyup' watchdog. * kick transmission by a fake scc_txint(scc), start 'maxkeyup' watchdog.
*/ */
static void t_txdelay(unsigned long channel) static void t_txdelay(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_t);
scc_start_maxkeyup(scc); scc_start_maxkeyup(scc);
@ -1184,9 +1186,9 @@ static void t_txdelay(unsigned long channel)
* transmission after 'mintime' seconds * transmission after 'mintime' seconds
*/ */
static void t_tail(unsigned long channel) static void t_tail(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_t);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&scc->lock, flags); spin_lock_irqsave(&scc->lock, flags);
@ -1211,9 +1213,9 @@ static void t_tail(unsigned long channel)
* throw away send buffers if DCD remains active too long. * throw away send buffers if DCD remains active too long.
*/ */
static void t_busy(unsigned long channel) static void t_busy(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_wdog);
del_timer(&scc->tx_t); del_timer(&scc->tx_t);
netif_stop_queue(scc->dev); /* don't pile on the wabbit! */ netif_stop_queue(scc->dev); /* don't pile on the wabbit! */
@ -1230,9 +1232,9 @@ static void t_busy(unsigned long channel)
* this is our watchdog. * this is our watchdog.
*/ */
static void t_maxkeyup(unsigned long channel) static void t_maxkeyup(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_wdog);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&scc->lock, flags); spin_lock_irqsave(&scc->lock, flags);
@ -1264,9 +1266,9 @@ static void t_maxkeyup(unsigned long channel)
* expires. * expires.
*/ */
static void t_idle(unsigned long channel) static void t_idle(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_t);
del_timer(&scc->tx_wdog); del_timer(&scc->tx_wdog);
@ -1397,9 +1399,9 @@ static unsigned long scc_get_param(struct scc_channel *scc, unsigned int cmd)
/* * Send calibration pattern * */ /* * Send calibration pattern * */
/* ******************************************************************* */ /* ******************************************************************* */
static void scc_stop_calibrate(unsigned long channel) static void scc_stop_calibrate(struct timer_list *t)
{ {
struct scc_channel *scc = (struct scc_channel *) channel; struct scc_channel *scc = from_timer(scc, t, tx_wdog);
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&scc->lock, flags); spin_lock_irqsave(&scc->lock, flags);
@ -1426,8 +1428,7 @@ scc_start_calibrate(struct scc_channel *scc, int duration, unsigned char pattern
del_timer(&scc->tx_wdog); del_timer(&scc->tx_wdog);
scc->tx_wdog.data = (unsigned long) scc; scc->tx_wdog.function = (TIMER_FUNC_TYPE)scc_stop_calibrate;
scc->tx_wdog.function = scc_stop_calibrate;
scc->tx_wdog.expires = jiffies + HZ*duration; scc->tx_wdog.expires = jiffies + HZ*duration;
add_timer(&scc->tx_wdog); add_timer(&scc->tx_wdog);
@ -1522,8 +1523,8 @@ static int scc_net_alloc(const char *name, struct scc_channel *scc)
dev->ml_priv = scc; dev->ml_priv = scc;
scc->dev = dev; scc->dev = dev;
spin_lock_init(&scc->lock); spin_lock_init(&scc->lock);
init_timer(&scc->tx_t); timer_setup(&scc->tx_t, NULL, 0);
init_timer(&scc->tx_wdog); timer_setup(&scc->tx_wdog, NULL, 0);
err = register_netdevice(dev); err = register_netdevice(dev);
if (err) { if (err) {

View File

@ -611,9 +611,9 @@ static void catc_stats_done(struct catc *catc, struct ctrl_queue *q)
catc->stats_vals[index >> 1] = data; catc->stats_vals[index >> 1] = data;
} }
static void catc_stats_timer(unsigned long data) static void catc_stats_timer(struct timer_list *t)
{ {
struct catc *catc = (void *) data; struct catc *catc = from_timer(catc, t, timer);
int i; int i;
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
@ -805,7 +805,7 @@ static int catc_probe(struct usb_interface *intf, const struct usb_device_id *id
spin_lock_init(&catc->tx_lock); spin_lock_init(&catc->tx_lock);
spin_lock_init(&catc->ctrl_lock); spin_lock_init(&catc->ctrl_lock);
setup_timer(&catc->timer, catc_stats_timer, (long)catc); timer_setup(&catc->timer, catc_stats_timer, 0);
catc->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL); catc->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
catc->tx_urb = usb_alloc_urb(0, GFP_KERNEL); catc->tx_urb = usb_alloc_urb(0, GFP_KERNEL);

View File

@ -3516,11 +3516,9 @@ static const struct net_device_ops lan78xx_netdev_ops = {
.ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid, .ndo_vlan_rx_kill_vid = lan78xx_vlan_rx_kill_vid,
}; };
static void lan78xx_stat_monitor(unsigned long param) static void lan78xx_stat_monitor(struct timer_list *t)
{ {
struct lan78xx_net *dev; struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
dev = (struct lan78xx_net *)param;
lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE); lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
} }
@ -3571,10 +3569,8 @@ static int lan78xx_probe(struct usb_interface *intf,
netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES; netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
netdev->ethtool_ops = &lan78xx_ethtool_ops; netdev->ethtool_ops = &lan78xx_ethtool_ops;
dev->stat_monitor.function = lan78xx_stat_monitor;
dev->stat_monitor.data = (unsigned long)dev;
dev->delta = 1; dev->delta = 1;
init_timer(&dev->stat_monitor); timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
mutex_init(&dev->stats.access_lock); mutex_init(&dev->stats.access_lock);

View File

@ -189,9 +189,6 @@ struct lsi_umts_dual {
#define SIERRA_NET_LSI_UMTS_DS_STATUS_LEN \ #define SIERRA_NET_LSI_UMTS_DS_STATUS_LEN \
(SIERRA_NET_LSI_UMTS_DS_LEN - SIERRA_NET_LSI_COMMON_LEN) (SIERRA_NET_LSI_UMTS_DS_LEN - SIERRA_NET_LSI_COMMON_LEN)
/* Forward definitions */
static void sierra_sync_timer(unsigned long syncdata);
/* Our own net device operations structure */ /* Our own net device operations structure */
static const struct net_device_ops sierra_net_device_ops = { static const struct net_device_ops sierra_net_device_ops = {
.ndo_open = usbnet_open, .ndo_open = usbnet_open,
@ -475,8 +472,6 @@ static void sierra_net_dosync(struct usbnet *dev)
"Send SYNC failed, status %d\n", status); "Send SYNC failed, status %d\n", status);
/* Now, start a timer and make sure we get the Restart Indication */ /* Now, start a timer and make sure we get the Restart Indication */
priv->sync_timer.function = sierra_sync_timer;
priv->sync_timer.data = (unsigned long) dev;
priv->sync_timer.expires = jiffies + SIERRA_NET_SYNCDELAY; priv->sync_timer.expires = jiffies + SIERRA_NET_SYNCDELAY;
add_timer(&priv->sync_timer); add_timer(&priv->sync_timer);
} }
@ -593,9 +588,10 @@ static void sierra_net_defer_kevent(struct usbnet *dev, int work)
/* /*
* Sync Retransmit Timer Handler. On expiry, kick the work queue * Sync Retransmit Timer Handler. On expiry, kick the work queue
*/ */
static void sierra_sync_timer(unsigned long syncdata) static void sierra_sync_timer(struct timer_list *t)
{ {
struct usbnet *dev = (struct usbnet *)syncdata; struct sierra_net_data *priv = from_timer(priv, t, sync_timer);
struct usbnet *dev = priv->usbnet;
dev_dbg(&dev->udev->dev, "%s", __func__); dev_dbg(&dev->udev->dev, "%s", __func__);
/* Kick the tasklet */ /* Kick the tasklet */
@ -752,7 +748,7 @@ static int sierra_net_bind(struct usbnet *dev, struct usb_interface *intf)
INIT_WORK(&priv->sierra_net_kevent, sierra_net_kevent); INIT_WORK(&priv->sierra_net_kevent, sierra_net_kevent);
/* Only need to do this once */ /* Only need to do this once */
init_timer(&priv->sync_timer); timer_setup(&priv->sync_timer, sierra_sync_timer, 0);
/* verify fw attributes */ /* verify fw attributes */
status = sierra_net_get_fw_attr(dev, &fwattr); status = sierra_net_get_fw_attr(dev, &fwattr);

View File

@ -1509,9 +1509,9 @@ err:
// tasklet (work deferred from completions, in_irq) or timer // tasklet (work deferred from completions, in_irq) or timer
static void usbnet_bh (unsigned long param) static void usbnet_bh (struct timer_list *t)
{ {
struct usbnet *dev = (struct usbnet *) param; struct usbnet *dev = from_timer(dev, t, delay);
struct sk_buff *skb; struct sk_buff *skb;
struct skb_data *entry; struct skb_data *entry;
@ -1694,13 +1694,11 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
skb_queue_head_init (&dev->txq); skb_queue_head_init (&dev->txq);
skb_queue_head_init (&dev->done); skb_queue_head_init (&dev->done);
skb_queue_head_init(&dev->rxq_pause); skb_queue_head_init(&dev->rxq_pause);
dev->bh.func = usbnet_bh; dev->bh.func = (void (*)(unsigned long))usbnet_bh;
dev->bh.data = (unsigned long) dev; dev->bh.data = (unsigned long)&dev->delay;
INIT_WORK (&dev->kevent, usbnet_deferred_kevent); INIT_WORK (&dev->kevent, usbnet_deferred_kevent);
init_usb_anchor(&dev->deferred); init_usb_anchor(&dev->deferred);
dev->delay.function = usbnet_bh; timer_setup(&dev->delay, usbnet_bh, 0);
dev->delay.data = (unsigned long) dev;
init_timer (&dev->delay);
mutex_init (&dev->phy_mutex); mutex_init (&dev->phy_mutex);
mutex_init(&dev->interrupt_mutex); mutex_init(&dev->interrupt_mutex);
dev->interrupt_count = 0; dev->interrupt_count = 0;

View File

@ -54,6 +54,7 @@ struct cisco_state {
cisco_proto settings; cisco_proto settings;
struct timer_list timer; struct timer_list timer;
struct net_device *dev;
spinlock_t lock; spinlock_t lock;
unsigned long last_poll; unsigned long last_poll;
int up; int up;
@ -257,11 +258,10 @@ rx_error:
static void cisco_timer(unsigned long arg) static void cisco_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)arg; struct cisco_state *st = from_timer(st, t, timer);
hdlc_device *hdlc = dev_to_hdlc(dev); struct net_device *dev = st->dev;
struct cisco_state *st = state(hdlc);
spin_lock(&st->lock); spin_lock(&st->lock);
if (st->up && if (st->up &&
@ -276,8 +276,6 @@ static void cisco_timer(unsigned long arg)
spin_unlock(&st->lock); spin_unlock(&st->lock);
st->timer.expires = jiffies + st->settings.interval * HZ; st->timer.expires = jiffies + st->settings.interval * HZ;
st->timer.function = cisco_timer;
st->timer.data = arg;
add_timer(&st->timer); add_timer(&st->timer);
} }
@ -293,7 +291,8 @@ static void cisco_start(struct net_device *dev)
st->up = st->txseq = st->rxseq = 0; st->up = st->txseq = st->rxseq = 0;
spin_unlock_irqrestore(&st->lock, flags); spin_unlock_irqrestore(&st->lock, flags);
setup_timer(&st->timer, cisco_timer, (unsigned long)dev); st->dev = dev;
timer_setup(&st->timer, cisco_timer, 0);
st->timer.expires = jiffies + HZ; /* First poll after 1 s */ st->timer.expires = jiffies + HZ; /* First poll after 1 s */
add_timer(&st->timer); add_timer(&st->timer);
} }

View File

@ -140,6 +140,7 @@ struct frad_state {
int dce_pvc_count; int dce_pvc_count;
struct timer_list timer; struct timer_list timer;
struct net_device *dev;
unsigned long last_poll; unsigned long last_poll;
int reliable; int reliable;
int dce_changed; int dce_changed;
@ -597,9 +598,10 @@ static void fr_set_link_state(int reliable, struct net_device *dev)
} }
static void fr_timer(unsigned long arg) static void fr_timer(struct timer_list *t)
{ {
struct net_device *dev = (struct net_device *)arg; struct frad_state *st = from_timer(st, t, timer);
struct net_device *dev = st->dev;
hdlc_device *hdlc = dev_to_hdlc(dev); hdlc_device *hdlc = dev_to_hdlc(dev);
int i, cnt = 0, reliable; int i, cnt = 0, reliable;
u32 list; u32 list;
@ -644,8 +646,6 @@ static void fr_timer(unsigned long arg)
state(hdlc)->settings.t391 * HZ; state(hdlc)->settings.t391 * HZ;
} }
state(hdlc)->timer.function = fr_timer;
state(hdlc)->timer.data = arg;
add_timer(&state(hdlc)->timer); add_timer(&state(hdlc)->timer);
} }
@ -1003,8 +1003,8 @@ static void fr_start(struct net_device *dev)
state(hdlc)->n391cnt = 0; state(hdlc)->n391cnt = 0;
state(hdlc)->txseq = state(hdlc)->rxseq = 0; state(hdlc)->txseq = state(hdlc)->rxseq = 0;
setup_timer(&state(hdlc)->timer, fr_timer, state(hdlc)->dev = dev;
(unsigned long)dev); timer_setup(&state(hdlc)->timer, fr_timer, 0);
/* First poll after 1 s */ /* First poll after 1 s */
state(hdlc)->timer.expires = jiffies + HZ; state(hdlc)->timer.expires = jiffies + HZ;
add_timer(&state(hdlc)->timer); add_timer(&state(hdlc)->timer);

View File

@ -92,7 +92,7 @@ static const struct iw_handler_def ray_handler_def;
/***** Prototypes for raylink functions **************************************/ /***** Prototypes for raylink functions **************************************/
static void authenticate(ray_dev_t *local); static void authenticate(ray_dev_t *local);
static int build_auth_frame(ray_dev_t *local, UCHAR *dest, int auth_type); static int build_auth_frame(ray_dev_t *local, UCHAR *dest, int auth_type);
static void authenticate_timeout(u_long); static void authenticate_timeout(struct timer_list *t);
static int get_free_ccs(ray_dev_t *local); static int get_free_ccs(ray_dev_t *local);
static int get_free_tx_ccs(ray_dev_t *local); static int get_free_tx_ccs(ray_dev_t *local);
static void init_startup_params(ray_dev_t *local); static void init_startup_params(ray_dev_t *local);
@ -102,7 +102,7 @@ static int ray_init(struct net_device *dev);
static int interrupt_ecf(ray_dev_t *local, int ccs); static int interrupt_ecf(ray_dev_t *local, int ccs);
static void ray_reset(struct net_device *dev); static void ray_reset(struct net_device *dev);
static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value, int len); static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value, int len);
static void verify_dl_startup(u_long); static void verify_dl_startup(struct timer_list *t);
/* Prototypes for interrpt time functions **********************************/ /* Prototypes for interrpt time functions **********************************/
static irqreturn_t ray_interrupt(int reg, void *dev_id); static irqreturn_t ray_interrupt(int reg, void *dev_id);
@ -120,9 +120,8 @@ static void associate(ray_dev_t *local);
/* Card command functions */ /* Card command functions */
static int dl_startup_params(struct net_device *dev); static int dl_startup_params(struct net_device *dev);
static void join_net(u_long local); static void join_net(struct timer_list *t);
static void start_net(u_long local); static void start_net(struct timer_list *t);
/* void start_net(ray_dev_t *local); */
/*===========================================================================*/ /*===========================================================================*/
/* Parameters that can be set with 'insmod' */ /* Parameters that can be set with 'insmod' */
@ -323,7 +322,7 @@ static int ray_probe(struct pcmcia_device *p_dev)
dev_dbg(&p_dev->dev, "ray_cs ray_attach calling ether_setup.)\n"); dev_dbg(&p_dev->dev, "ray_cs ray_attach calling ether_setup.)\n");
netif_stop_queue(dev); netif_stop_queue(dev);
init_timer(&local->timer); timer_setup(&local->timer, NULL, 0);
this_device = p_dev; this_device = p_dev;
return ray_config(p_dev); return ray_config(p_dev);
@ -570,8 +569,7 @@ static int dl_startup_params(struct net_device *dev)
local->card_status = CARD_DL_PARAM; local->card_status = CARD_DL_PARAM;
/* Start kernel timer to wait for dl startup to complete. */ /* Start kernel timer to wait for dl startup to complete. */
local->timer.expires = jiffies + HZ / 2; local->timer.expires = jiffies + HZ / 2;
local->timer.data = (long)local; local->timer.function = (TIMER_FUNC_TYPE)verify_dl_startup;
local->timer.function = verify_dl_startup;
add_timer(&local->timer); add_timer(&local->timer);
dev_dbg(&link->dev, dev_dbg(&link->dev,
"ray_cs dl_startup_params started timer for verify_dl_startup\n"); "ray_cs dl_startup_params started timer for verify_dl_startup\n");
@ -641,9 +639,9 @@ static void init_startup_params(ray_dev_t *local)
} /* init_startup_params */ } /* init_startup_params */
/*===========================================================================*/ /*===========================================================================*/
static void verify_dl_startup(u_long data) static void verify_dl_startup(struct timer_list *t)
{ {
ray_dev_t *local = (ray_dev_t *) data; ray_dev_t *local = from_timer(local, t, timer);
struct ccs __iomem *pccs = ccs_base(local) + local->dl_param_ccs; struct ccs __iomem *pccs = ccs_base(local) + local->dl_param_ccs;
UCHAR status; UCHAR status;
struct pcmcia_device *link = local->finder; struct pcmcia_device *link = local->finder;
@ -676,16 +674,16 @@ static void verify_dl_startup(u_long data)
return; return;
} }
if (local->sparm.b4.a_network_type == ADHOC) if (local->sparm.b4.a_network_type == ADHOC)
start_net((u_long) local); start_net(&local->timer);
else else
join_net((u_long) local); join_net(&local->timer);
} /* end verify_dl_startup */ } /* end verify_dl_startup */
/*===========================================================================*/ /*===========================================================================*/
/* Command card to start a network */ /* Command card to start a network */
static void start_net(u_long data) static void start_net(struct timer_list *t)
{ {
ray_dev_t *local = (ray_dev_t *) data; ray_dev_t *local = from_timer(local, t, timer);
struct ccs __iomem *pccs; struct ccs __iomem *pccs;
int ccsindex; int ccsindex;
struct pcmcia_device *link = local->finder; struct pcmcia_device *link = local->finder;
@ -710,9 +708,9 @@ static void start_net(u_long data)
/*===========================================================================*/ /*===========================================================================*/
/* Command card to join a network */ /* Command card to join a network */
static void join_net(u_long data) static void join_net(struct timer_list *t)
{ {
ray_dev_t *local = (ray_dev_t *) data; ray_dev_t *local = from_timer(local, t, timer);
struct ccs __iomem *pccs; struct ccs __iomem *pccs;
int ccsindex; int ccsindex;
@ -1639,13 +1637,13 @@ static int get_free_ccs(ray_dev_t *local)
} /* get_free_ccs */ } /* get_free_ccs */
/*===========================================================================*/ /*===========================================================================*/
static void authenticate_timeout(u_long data) static void authenticate_timeout(struct timer_list *t)
{ {
ray_dev_t *local = (ray_dev_t *) data; ray_dev_t *local = from_timer(local, t, timer);
del_timer(&local->timer); del_timer(&local->timer);
printk(KERN_INFO "ray_cs Authentication with access point failed" printk(KERN_INFO "ray_cs Authentication with access point failed"
" - timeout\n"); " - timeout\n");
join_net((u_long) local); join_net(&local->timer);
} }
/*===========================================================================*/ /*===========================================================================*/
@ -1945,17 +1943,16 @@ static irqreturn_t ray_interrupt(int irq, void *dev_id)
del_timer(&local->timer); del_timer(&local->timer);
local->timer.expires = jiffies + HZ * 5; local->timer.expires = jiffies + HZ * 5;
local->timer.data = (long)local;
if (status == CCS_START_NETWORK) { if (status == CCS_START_NETWORK) {
dev_dbg(&link->dev, dev_dbg(&link->dev,
"ray_cs interrupt network \"%s\" start failed\n", "ray_cs interrupt network \"%s\" start failed\n",
memtmp); memtmp);
local->timer.function = start_net; local->timer.function = (TIMER_FUNC_TYPE)start_net;
} else { } else {
dev_dbg(&link->dev, dev_dbg(&link->dev,
"ray_cs interrupt network \"%s\" join failed\n", "ray_cs interrupt network \"%s\" join failed\n",
memtmp); memtmp);
local->timer.function = join_net; local->timer.function = (TIMER_FUNC_TYPE)join_net;
} }
add_timer(&local->timer); add_timer(&local->timer);
} }
@ -1967,7 +1964,7 @@ static irqreturn_t ray_interrupt(int irq, void *dev_id)
} else { } else {
dev_dbg(&link->dev, "ray_cs association failed,\n"); dev_dbg(&link->dev, "ray_cs association failed,\n");
local->card_status = CARD_ASSOC_FAILED; local->card_status = CARD_ASSOC_FAILED;
join_net((u_long) local); join_net(&local->timer);
} }
break; break;
case CCS_TX_REQUEST: case CCS_TX_REQUEST:
@ -2420,12 +2417,11 @@ static void authenticate(ray_dev_t *local)
del_timer(&local->timer); del_timer(&local->timer);
if (build_auth_frame(local, local->bss_id, OPEN_AUTH_REQUEST)) { if (build_auth_frame(local, local->bss_id, OPEN_AUTH_REQUEST)) {
local->timer.function = join_net; local->timer.function = (TIMER_FUNC_TYPE)join_net;
} else { } else {
local->timer.function = authenticate_timeout; local->timer.function = (TIMER_FUNC_TYPE)authenticate_timeout;
} }
local->timer.expires = jiffies + HZ * 2; local->timer.expires = jiffies + HZ * 2;
local->timer.data = (long)local;
add_timer(&local->timer); add_timer(&local->timer);
local->authentication_state = AWAITING_RESPONSE; local->authentication_state = AWAITING_RESPONSE;
} /* end authenticate */ } /* end authenticate */
@ -2468,7 +2464,7 @@ static void rx_authenticate(ray_dev_t *local, struct rcs __iomem *prcs,
} else { } else {
pr_debug("Authentication refused\n"); pr_debug("Authentication refused\n");
local->card_status = CARD_AUTH_REFUSED; local->card_status = CARD_AUTH_REFUSED;
join_net((u_long) local); join_net(&local->timer);
local->authentication_state = local->authentication_state =
UNAUTHENTICATED; UNAUTHENTICATED;
} }
@ -2506,8 +2502,7 @@ static void associate(ray_dev_t *local)
del_timer(&local->timer); del_timer(&local->timer);
local->timer.expires = jiffies + HZ * 2; local->timer.expires = jiffies + HZ * 2;
local->timer.data = (long)local; local->timer.function = (TIMER_FUNC_TYPE)join_net;
local->timer.function = join_net;
add_timer(&local->timer); add_timer(&local->timer);
local->card_status = CARD_ASSOC_FAILED; local->card_status = CARD_ASSOC_FAILED;
return; return;

View File

@ -91,7 +91,7 @@ struct cw1200_suspend_state {
u8 prev_ps_mode; u8 prev_ps_mode;
}; };
static void cw1200_pm_stay_awake_tmo(unsigned long arg) static void cw1200_pm_stay_awake_tmo(struct timer_list *unused)
{ {
/* XXX what's the point of this ? */ /* XXX what's the point of this ? */
} }
@ -101,8 +101,7 @@ int cw1200_pm_init(struct cw1200_pm_state *pm,
{ {
spin_lock_init(&pm->lock); spin_lock_init(&pm->lock);
setup_timer(&pm->stay_awake, cw1200_pm_stay_awake_tmo, timer_setup(&pm->stay_awake, cw1200_pm_stay_awake_tmo, 0);
(unsigned long)pm);
return 0; return 0;
} }

Some files were not shown because too many files have changed in this diff Show More