mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-10-04 08:08:54 +00:00
Code Issues Releases Wiki Activity

Merge branch 'ethernet-convert-tasklets-to-use-new-tasklet_setup-API'

Browse source 
Allen Pais says:

====================
ethernet: convert tasklets to use new tasklet_setup API

Commit 12cc923f1c ("tasklet: Introduce new initialization API")'
introduced a new tasklet initialization API. This series converts
all the crypto modules to use the new tasklet_setup() API

This series is based on v5.9-rc5

v3:
  fix subject prefix
  use backpointer instead of fragile priv to netdev.

v2:
  fix kdoc reported by Jakub Kicinski.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2020-09-14 13:02:38 -07:00
commit 26cdb8f72a
41 changed files with 183 additions and 223 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
drivers/net/ethernet/alteon/acenic.c
View file

@ -465,6 +465,7 @@ static int acenic_probe_one(struct pci_dev *pdev,
SET_NETDEV_DEV(dev, &pdev->dev); SET_NETDEV_DEV(dev, &pdev->dev);
ap = netdev_priv(dev); ap = netdev_priv(dev);
ap->ndev = dev;
ap->pdev = pdev; ap->pdev = pdev;
ap->name = pci_name(pdev); ap->name = pci_name(pdev);
@ -1562,10 +1563,10 @@ static void ace_watchdog(struct net_device *data, unsigned int txqueue)
} }
static void ace_tasklet(unsigned long arg) static void ace_tasklet(struct tasklet_struct *t)
{ {
struct net_device *dev = (struct net_device *) arg; struct ace_private *ap = from_tasklet(ap, t, ace_tasklet);
struct ace_private *ap = netdev_priv(dev); struct net_device *dev = ap->ndev;
int cur_size; int cur_size;
cur_size = atomic_read(&ap->cur_rx_bufs); cur_size = atomic_read(&ap->cur_rx_bufs);
@ -2269,7 +2270,7 @@ static int ace_open(struct net_device *dev)
/* /*
* Setup the bottom half rx ring refill handler * Setup the bottom half rx ring refill handler
*/ */
tasklet_init(&ap->ace_tasklet, ace_tasklet, (unsigned long)dev); tasklet_setup(&ap->ace_tasklet, ace_tasklet);
return 0; return 0;
} }

3
drivers/net/ethernet/alteon/acenic.h
View file

@ -633,6 +633,7 @@ struct ace_skb
*/ */
struct ace_private struct ace_private
{ {
struct net_device *ndev; /* backpointer */
struct ace_info *info; struct ace_info *info;
struct ace_regs __iomem *regs; /* register base */ struct ace_regs __iomem *regs; /* register base */
struct ace_skb *skb; struct ace_skb *skb;
@ -776,7 +777,7 @@ static int ace_open(struct net_device *dev);
static netdev_tx_t ace_start_xmit(struct sk_buff *skb, static netdev_tx_t ace_start_xmit(struct sk_buff *skb,
struct net_device *dev); struct net_device *dev);
static int ace_close(struct net_device *dev); static int ace_close(struct net_device *dev);
static void ace_tasklet(unsigned long dev); static void ace_tasklet(struct tasklet_struct *t);
static void ace_dump_trace(struct ace_private *ap); static void ace_dump_trace(struct ace_private *ap);
static void ace_set_multicast_list(struct net_device *dev); static void ace_set_multicast_list(struct net_device *dev);
static int ace_change_mtu(struct net_device *dev, int new_mtu); static int ace_change_mtu(struct net_device *dev, int new_mtu);

19
drivers/net/ethernet/amd/xgbe/xgbe-drv.c
View file

@ -403,9 +403,9 @@ static bool xgbe_ecc_ded(struct xgbe_prv_data *pdata, unsigned long *period,
return false; return false;
} }
static void xgbe_ecc_isr_task(unsigned long data) static void xgbe_ecc_isr_task(struct tasklet_struct *t)
{ {
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data; struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_ecc);
unsigned int ecc_isr; unsigned int ecc_isr;
bool stop = false; bool stop = false;
@ -468,14 +468,14 @@ static irqreturn_t xgbe_ecc_isr(int irq, void *data)
if (pdata->isr_as_tasklet) if (pdata->isr_as_tasklet)
tasklet_schedule(&pdata->tasklet_ecc); tasklet_schedule(&pdata->tasklet_ecc);
else else
xgbe_ecc_isr_task((unsigned long)pdata); xgbe_ecc_isr_task(&pdata->tasklet_ecc);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void xgbe_isr_task(unsigned long data) static void xgbe_isr_task(struct tasklet_struct *t)
{ {
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data; struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_dev);
struct xgbe_hw_if *hw_if = &pdata->hw_if; struct xgbe_hw_if *hw_if = &pdata->hw_if;
struct xgbe_channel *channel; struct xgbe_channel *channel;
unsigned int dma_isr, dma_ch_isr; unsigned int dma_isr, dma_ch_isr;
@ -582,7 +582,7 @@ static void xgbe_isr_task(unsigned long data)
/* If there is not a separate ECC irq, handle it here */ /* If there is not a separate ECC irq, handle it here */
if (pdata->vdata->ecc_support && (pdata->dev_irq == pdata->ecc_irq)) if (pdata->vdata->ecc_support && (pdata->dev_irq == pdata->ecc_irq))
xgbe_ecc_isr_task((unsigned long)pdata); xgbe_ecc_isr_task(&pdata->tasklet_ecc);
/* If there is not a separate I2C irq, handle it here */ /* If there is not a separate I2C irq, handle it here */
if (pdata->vdata->i2c_support && (pdata->dev_irq == pdata->i2c_irq)) if (pdata->vdata->i2c_support && (pdata->dev_irq == pdata->i2c_irq))
@ -607,7 +607,7 @@ static irqreturn_t xgbe_isr(int irq, void *data)
if (pdata->isr_as_tasklet) if (pdata->isr_as_tasklet)
tasklet_schedule(&pdata->tasklet_dev); tasklet_schedule(&pdata->tasklet_dev);
else else
xgbe_isr_task((unsigned long)pdata); xgbe_isr_task(&pdata->tasklet_dev);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -991,9 +991,8 @@ static int xgbe_request_irqs(struct xgbe_prv_data *pdata)
unsigned int i; unsigned int i;
int ret; int ret;
tasklet_init(&pdata->tasklet_dev, xgbe_isr_task, (unsigned long)pdata); tasklet_setup(&pdata->tasklet_dev, xgbe_isr_task);
tasklet_init(&pdata->tasklet_ecc, xgbe_ecc_isr_task, tasklet_setup(&pdata->tasklet_ecc, xgbe_ecc_isr_task);
(unsigned long)pdata);
ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0, ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0,
netdev_name(netdev), pdata); netdev_name(netdev), pdata);

11
drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
View file

@ -274,9 +274,9 @@ static void xgbe_i2c_clear_isr_interrupts(struct xgbe_prv_data *pdata,
XI2C_IOREAD(pdata, IC_CLR_STOP_DET); XI2C_IOREAD(pdata, IC_CLR_STOP_DET);
} }
static void xgbe_i2c_isr_task(unsigned long data) static void xgbe_i2c_isr_task(struct tasklet_struct *t)
{ {
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data; struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_i2c);
struct xgbe_i2c_op_state *state = &pdata->i2c.op_state; struct xgbe_i2c_op_state *state = &pdata->i2c.op_state;
unsigned int isr; unsigned int isr;
@ -324,7 +324,7 @@ static irqreturn_t xgbe_i2c_isr(int irq, void *data)
if (pdata->isr_as_tasklet) if (pdata->isr_as_tasklet)
tasklet_schedule(&pdata->tasklet_i2c); tasklet_schedule(&pdata->tasklet_i2c);
else else
xgbe_i2c_isr_task((unsigned long)pdata); xgbe_i2c_isr_task(&pdata->tasklet_i2c);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -369,7 +369,7 @@ static void xgbe_i2c_set_target(struct xgbe_prv_data *pdata, unsigned int addr)
static irqreturn_t xgbe_i2c_combined_isr(struct xgbe_prv_data *pdata) static irqreturn_t xgbe_i2c_combined_isr(struct xgbe_prv_data *pdata)
{ {
xgbe_i2c_isr_task((unsigned long)pdata); xgbe_i2c_isr_task(&pdata->tasklet_i2c);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -462,8 +462,7 @@ static int xgbe_i2c_start(struct xgbe_prv_data *pdata)
/* If we have a separate I2C irq, enable it */ /* If we have a separate I2C irq, enable it */
if (pdata->dev_irq != pdata->i2c_irq) { if (pdata->dev_irq != pdata->i2c_irq) {
tasklet_init(&pdata->tasklet_i2c, xgbe_i2c_isr_task, tasklet_setup(&pdata->tasklet_i2c, xgbe_i2c_isr_task);
(unsigned long)pdata);
ret = devm_request_irq(pdata->dev, pdata->i2c_irq, ret = devm_request_irq(pdata->dev, pdata->i2c_irq,
xgbe_i2c_isr, 0, pdata->i2c_name, xgbe_i2c_isr, 0, pdata->i2c_name,

11
drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
View file

@ -688,9 +688,9 @@ static void xgbe_an73_isr(struct xgbe_prv_data *pdata)
} }
} }
static void xgbe_an_isr_task(unsigned long data) static void xgbe_an_isr_task(struct tasklet_struct *t)
{ {
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data; struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_an);
netif_dbg(pdata, intr, pdata->netdev, "AN interrupt received\n"); netif_dbg(pdata, intr, pdata->netdev, "AN interrupt received\n");
@ -715,14 +715,14 @@ static irqreturn_t xgbe_an_isr(int irq, void *data)
if (pdata->isr_as_tasklet) if (pdata->isr_as_tasklet)
tasklet_schedule(&pdata->tasklet_an); tasklet_schedule(&pdata->tasklet_an);
else else
xgbe_an_isr_task((unsigned long)pdata); xgbe_an_isr_task(&pdata->tasklet_an);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t xgbe_an_combined_isr(struct xgbe_prv_data *pdata) static irqreturn_t xgbe_an_combined_isr(struct xgbe_prv_data *pdata)
{ {
xgbe_an_isr_task((unsigned long)pdata); xgbe_an_isr_task(&pdata->tasklet_an);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
@ -1414,8 +1414,7 @@ static int xgbe_phy_start(struct xgbe_prv_data *pdata)
/* If we have a separate AN irq, enable it */ /* If we have a separate AN irq, enable it */
if (pdata->dev_irq != pdata->an_irq) { if (pdata->dev_irq != pdata->an_irq) {
tasklet_init(&pdata->tasklet_an, xgbe_an_isr_task, tasklet_setup(&pdata->tasklet_an, xgbe_an_isr_task);
(unsigned long)pdata);
ret = devm_request_irq(pdata->dev, pdata->an_irq, ret = devm_request_irq(pdata->dev, pdata->an_irq,
xgbe_an_isr, 0, pdata->an_name, xgbe_an_isr, 0, pdata->an_name,

18
drivers/net/ethernet/broadcom/cnic.c
View file

@ -3009,10 +3009,10 @@ static int cnic_service_bnx2(void *data, void *status_blk)
return cnic_service_bnx2_queues(dev); return cnic_service_bnx2_queues(dev);
} }
static void cnic_service_bnx2_msix(unsigned long data) static void cnic_service_bnx2_msix(struct tasklet_struct *t)
{ {
struct cnic_dev *dev = (struct cnic_dev *) data; struct cnic_local *cp = from_tasklet(cp, t, cnic_irq_task);
struct cnic_local *cp = dev->cnic_priv; struct cnic_dev *dev = cp->dev;
cp->last_status_idx = cnic_service_bnx2_queues(dev); cp->last_status_idx = cnic_service_bnx2_queues(dev);
@ -3134,10 +3134,10 @@ static u32 cnic_service_bnx2x_kcq(struct cnic_dev *dev, struct kcq_info *info)
return last_status; return last_status;
} }
static void cnic_service_bnx2x_bh(unsigned long data) static void cnic_service_bnx2x_bh(struct tasklet_struct *t)
{ {
struct cnic_dev *dev = (struct cnic_dev *) data; struct cnic_local *cp = from_tasklet(cp, t, cnic_irq_task);
struct cnic_local *cp = dev->cnic_priv; struct cnic_dev *dev = cp->dev;
struct bnx2x *bp = netdev_priv(dev->netdev); struct bnx2x *bp = netdev_priv(dev->netdev);
u32 status_idx, new_status_idx; u32 status_idx, new_status_idx;
@ -4458,8 +4458,7 @@ static int cnic_init_bnx2_irq(struct cnic_dev *dev)
CNIC_WR(dev, base + BNX2_HC_CMD_TICKS_OFF, (64 << 16) | 220); CNIC_WR(dev, base + BNX2_HC_CMD_TICKS_OFF, (64 << 16) | 220);
cp->last_status_idx = cp->status_blk.bnx2->status_idx; cp->last_status_idx = cp->status_blk.bnx2->status_idx;
tasklet_init(&cp->cnic_irq_task, cnic_service_bnx2_msix, tasklet_setup(&cp->cnic_irq_task, cnic_service_bnx2_msix);
(unsigned long) dev);
err = cnic_request_irq(dev); err = cnic_request_irq(dev);
if (err) if (err)
return err; return err;
@ -4868,8 +4867,7 @@ static int cnic_init_bnx2x_irq(struct cnic_dev *dev)
struct cnic_eth_dev *ethdev = cp->ethdev; struct cnic_eth_dev *ethdev = cp->ethdev;
int err = 0; int err = 0;
tasklet_init(&cp->cnic_irq_task, cnic_service_bnx2x_bh, tasklet_setup(&cp->cnic_irq_task, cnic_service_bnx2x_bh);
(unsigned long) dev);
if (ethdev->drv_state & CNIC_DRV_STATE_USING_MSIX) if (ethdev->drv_state & CNIC_DRV_STATE_USING_MSIX)
err = cnic_request_irq(dev); err = cnic_request_irq(dev);

7
drivers/net/ethernet/cadence/macb_main.c
View file

@ -1466,9 +1466,9 @@ static int macb_poll(struct napi_struct *napi, int budget)
return work_done; return work_done;
} }
static void macb_hresp_error_task(unsigned long data) static void macb_hresp_error_task(struct tasklet_struct *t)
{ {
struct macb *bp = (struct macb *)data; struct macb *bp = from_tasklet(bp, t, hresp_err_tasklet);
struct net_device *dev = bp->dev; struct net_device *dev = bp->dev;
struct macb_queue *queue; struct macb_queue *queue;
unsigned int q; unsigned int q;
@ -4560,8 +4560,7 @@ static int macb_probe(struct platform_device *pdev)
goto err_out_unregister_mdio; goto err_out_unregister_mdio;
} }
tasklet_init(&bp->hresp_err_tasklet, macb_hresp_error_task, tasklet_setup(&bp->hresp_err_tasklet, macb_hresp_error_task);
(unsigned long)bp);
netdev_info(dev, "Cadence %s rev 0x%08x at 0x%08lx irq %d (%pM)\n", netdev_info(dev, "Cadence %s rev 0x%08x at 0x%08lx irq %d (%pM)\n",
macb_is_gem(bp) ? "GEM" : "MACB", macb_readl(bp, MID), macb_is_gem(bp) ? "GEM" : "MACB", macb_readl(bp, MID),

12
drivers/net/ethernet/cavium/liquidio/lio_main.c
View file

@ -161,13 +161,13 @@ static int liquidio_set_vf_link_state(struct net_device *netdev, int vfidx,
static struct handshake handshake[MAX_OCTEON_DEVICES]; static struct handshake handshake[MAX_OCTEON_DEVICES];
static struct completion first_stage; static struct completion first_stage;
static void octeon_droq_bh(unsigned long pdev) static void octeon_droq_bh(struct tasklet_struct *t)
{ {
int q_no; int q_no;
int reschedule = 0; int reschedule = 0;
struct octeon_device *oct = (struct octeon_device *)pdev; struct octeon_device_priv *oct_priv = from_tasklet(oct_priv, t,
struct octeon_device_priv *oct_priv = droq_tasklet);
(struct octeon_device_priv *)oct->priv; struct octeon_device *oct = oct_priv->dev;
for (q_no = 0; q_no < MAX_OCTEON_OUTPUT_QUEUES(oct); q_no++) { for (q_no = 0; q_no < MAX_OCTEON_OUTPUT_QUEUES(oct); q_no++) {
if (!(oct->io_qmask.oq & BIT_ULL(q_no))) if (!(oct->io_qmask.oq & BIT_ULL(q_no)))
@ -4193,8 +4193,7 @@ static int octeon_device_init(struct octeon_device *octeon_dev)
/* Initialize the tasklet that handles output queue packet processing.*/ /* Initialize the tasklet that handles output queue packet processing.*/
dev_dbg(&octeon_dev->pci_dev->dev, "Initializing droq tasklet\n"); dev_dbg(&octeon_dev->pci_dev->dev, "Initializing droq tasklet\n");
tasklet_init(&oct_priv->droq_tasklet, octeon_droq_bh, tasklet_setup(&oct_priv->droq_tasklet, octeon_droq_bh);
(unsigned long)octeon_dev);
/* Setup the interrupt handler and record the INT SUM register address /* Setup the interrupt handler and record the INT SUM register address
*/ */
@ -4298,6 +4297,7 @@ static int octeon_device_init(struct octeon_device *octeon_dev)
complete(&handshake[octeon_dev->octeon_id].init); complete(&handshake[octeon_dev->octeon_id].init);
atomic_set(&octeon_dev->status, OCT_DEV_HOST_OK); atomic_set(&octeon_dev->status, OCT_DEV_HOST_OK);
oct_priv->dev = octeon_dev;
return 0; return 0;
} }

1
drivers/net/ethernet/cavium/liquidio/octeon_main.h
View file

@ -39,6 +39,7 @@ struct octeon_device_priv {
/** Tasklet structures for this device. */ /** Tasklet structures for this device. */
struct tasklet_struct droq_tasklet; struct tasklet_struct droq_tasklet;
unsigned long napi_mask; unsigned long napi_mask;
struct octeon_device *dev;
}; };
/** This structure is used by NIC driver to store information required /** This structure is used by NIC driver to store information required

8
drivers/net/ethernet/cavium/octeon/octeon_mgmt.c
View file

@ -315,9 +315,9 @@ static void octeon_mgmt_clean_tx_buffers(struct octeon_mgmt *p)
netif_wake_queue(p->netdev); netif_wake_queue(p->netdev);
} }
static void octeon_mgmt_clean_tx_tasklet(unsigned long arg) static void octeon_mgmt_clean_tx_tasklet(struct tasklet_struct *t)
{ {
struct octeon_mgmt *p = (struct octeon_mgmt *)arg; struct octeon_mgmt *p = from_tasklet(p, t, tx_clean_tasklet);
octeon_mgmt_clean_tx_buffers(p); octeon_mgmt_clean_tx_buffers(p);
octeon_mgmt_enable_tx_irq(p); octeon_mgmt_enable_tx_irq(p);
} }
@ -1489,8 +1489,8 @@ static int octeon_mgmt_probe(struct platform_device *pdev)
skb_queue_head_init(&p->tx_list); skb_queue_head_init(&p->tx_list);
skb_queue_head_init(&p->rx_list); skb_queue_head_init(&p->rx_list);
tasklet_init(&p->tx_clean_tasklet, tasklet_setup(&p->tx_clean_tasklet,
octeon_mgmt_clean_tx_tasklet, (unsigned long)p); octeon_mgmt_clean_tx_tasklet);
netdev->priv_flags |= IFF_UNICAST_FLT; netdev->priv_flags |= IFF_UNICAST_FLT;

10
drivers/net/ethernet/cavium/thunder/nicvf_main.c
View file

@ -985,9 +985,9 @@ static int nicvf_poll(struct napi_struct *napi, int budget)
* *
* As of now only CQ errors are handled * As of now only CQ errors are handled
*/ */
static void nicvf_handle_qs_err(unsigned long data) static void nicvf_handle_qs_err(struct tasklet_struct *t)
{ {
struct nicvf *nic = (struct nicvf *)data; struct nicvf *nic = from_tasklet(nic, t, qs_err_task);
struct queue_set *qs = nic->qs; struct queue_set *qs = nic->qs;
int qidx; int qidx;
u64 status; u64 status;
@ -1493,12 +1493,10 @@ int nicvf_open(struct net_device *netdev)
} }
/* Init tasklet for handling Qset err interrupt */ /* Init tasklet for handling Qset err interrupt */
tasklet_init(&nic->qs_err_task, nicvf_handle_qs_err, tasklet_setup(&nic->qs_err_task, nicvf_handle_qs_err);
(unsigned long)nic);
/* Init RBDR tasklet which will refill RBDR */ /* Init RBDR tasklet which will refill RBDR */
tasklet_init(&nic->rbdr_task, nicvf_rbdr_task, tasklet_setup(&nic->rbdr_task, nicvf_rbdr_task);
(unsigned long)nic);
INIT_DELAYED_WORK(&nic->rbdr_work, nicvf_rbdr_work); INIT_DELAYED_WORK(&nic->rbdr_work, nicvf_rbdr_work);
/* Configure CPI alorithm */ /* Configure CPI alorithm */

4
drivers/net/ethernet/cavium/thunder/nicvf_queues.c
View file

@ -460,9 +460,9 @@ void nicvf_rbdr_work(struct work_struct *work)
} }
/* In Softirq context, alloc rcv buffers in atomic mode */ /* In Softirq context, alloc rcv buffers in atomic mode */
void nicvf_rbdr_task(unsigned long data) void nicvf_rbdr_task(struct tasklet_struct *t)
{ {
struct nicvf *nic = (struct nicvf *)data; struct nicvf *nic = from_tasklet(nic, t, rbdr_task);
nicvf_refill_rbdr(nic, GFP_ATOMIC); nicvf_refill_rbdr(nic, GFP_ATOMIC);
if (nic->rb_alloc_fail) { if (nic->rb_alloc_fail) {

2
drivers/net/ethernet/cavium/thunder/nicvf_queues.h
View file

@ -348,7 +348,7 @@ void nicvf_xdp_sq_doorbell(struct nicvf *nic, struct snd_queue *sq, int sq_num);
struct sk_buff *nicvf_get_rcv_skb(struct nicvf *nic, struct sk_buff *nicvf_get_rcv_skb(struct nicvf *nic,
struct cqe_rx_t *cqe_rx, bool xdp); struct cqe_rx_t *cqe_rx, bool xdp);
void nicvf_rbdr_task(unsigned long data); void nicvf_rbdr_task(struct tasklet_struct *t);
void nicvf_rbdr_work(struct work_struct *work); void nicvf_rbdr_work(struct work_struct *work);
void nicvf_enable_intr(struct nicvf *nic, int int_type, int q_idx); void nicvf_enable_intr(struct nicvf *nic, int int_type, int q_idx);

12
drivers/net/ethernet/chelsio/cxgb/sge.c
View file

@ -239,8 +239,10 @@ struct sched {
unsigned int num; /* num skbs in per port queues */ unsigned int num; /* num skbs in per port queues */
struct sched_port p[MAX_NPORTS]; struct sched_port p[MAX_NPORTS];
struct tasklet_struct sched_tsk;/* tasklet used to run scheduler */ struct tasklet_struct sched_tsk;/* tasklet used to run scheduler */
struct sge *sge;
}; };
static void restart_sched(unsigned long);
static void restart_sched(struct tasklet_struct *t);
/* /*
@ -378,7 +380,8 @@ static int tx_sched_init(struct sge *sge)
return -ENOMEM; return -ENOMEM;
pr_debug("tx_sched_init\n"); pr_debug("tx_sched_init\n");
tasklet_init(&s->sched_tsk, restart_sched, (unsigned long) sge); tasklet_setup(&s->sched_tsk, restart_sched);
s->sge = sge;
sge->tx_sched = s; sge->tx_sched = s;
for (i = 0; i < MAX_NPORTS; i++) { for (i = 0; i < MAX_NPORTS; i++) {
@ -1305,9 +1308,10 @@ static inline void reclaim_completed_tx(struct sge *sge, struct cmdQ *q)
* Called from tasklet. Checks the scheduler for any * Called from tasklet. Checks the scheduler for any
* pending skbs that can be sent. * pending skbs that can be sent.
*/ */
static void restart_sched(unsigned long arg) static void restart_sched(struct tasklet_struct *t)
{ {
struct sge *sge = (struct sge *) arg; struct sched *s = from_tasklet(s, t, sched_tsk);
struct sge *sge = s->sge;
struct adapter *adapter = sge->adapter; struct adapter *adapter = sge->adapter;
struct cmdQ *q = &sge->cmdQ[0]; struct cmdQ *q = &sge->cmdQ[0];
struct sk_buff *skb; struct sk_buff *skb;

18
drivers/net/ethernet/chelsio/cxgb3/sge.c
View file

@ -1516,14 +1516,14 @@ static int ctrl_xmit(struct adapter *adap, struct sge_txq *q,
/** /**
* restart_ctrlq - restart a suspended control queue * restart_ctrlq - restart a suspended control queue
* @qs: the queue set cotaining the control queue * @t: pointer to the tasklet associated with this handler
* *
* Resumes transmission on a suspended Tx control queue. * Resumes transmission on a suspended Tx control queue.
*/ */
static void restart_ctrlq(unsigned long data) static void restart_ctrlq(struct tasklet_struct *t)
{ {
struct sk_buff *skb; struct sk_buff *skb;
struct sge_qset *qs = (struct sge_qset *)data; struct sge_qset *qs = from_tasklet(qs, t, txq[TXQ_CTRL].qresume_tsk);
struct sge_txq *q = &qs->txq[TXQ_CTRL]; struct sge_txq *q = &qs->txq[TXQ_CTRL];
spin_lock(&q->lock); spin_lock(&q->lock);
@ -1733,14 +1733,14 @@ again: reclaim_completed_tx(adap, q, TX_RECLAIM_CHUNK);
/** /**
* restart_offloadq - restart a suspended offload queue * restart_offloadq - restart a suspended offload queue
* @qs: the queue set cotaining the offload queue * @t: pointer to the tasklet associated with this handler
* *
* Resumes transmission on a suspended Tx offload queue. * Resumes transmission on a suspended Tx offload queue.
*/ */
static void restart_offloadq(unsigned long data) static void restart_offloadq(struct tasklet_struct *t)
{ {
struct sk_buff *skb; struct sk_buff *skb;
struct sge_qset *qs = (struct sge_qset *)data; struct sge_qset *qs = from_tasklet(qs, t, txq[TXQ_OFLD].qresume_tsk);
struct sge_txq *q = &qs->txq[TXQ_OFLD]; struct sge_txq *q = &qs->txq[TXQ_OFLD];
const struct port_info *pi = netdev_priv(qs->netdev); const struct port_info *pi = netdev_priv(qs->netdev);
struct adapter *adap = pi->adapter; struct adapter *adap = pi->adapter;
@ -3081,10 +3081,8 @@ int t3_sge_alloc_qset(struct adapter *adapter, unsigned int id, int nports,
skb_queue_head_init(&q->txq[i].sendq); skb_queue_head_init(&q->txq[i].sendq);
} }
tasklet_init(&q->txq[TXQ_OFLD].qresume_tsk, restart_offloadq, tasklet_setup(&q->txq[TXQ_OFLD].qresume_tsk, restart_offloadq);
(unsigned long)q); tasklet_setup(&q->txq[TXQ_CTRL].qresume_tsk, restart_ctrlq);
tasklet_init(&q->txq[TXQ_CTRL].qresume_tsk, restart_ctrlq,
(unsigned long)q);
q->fl[0].gen = q->fl[1].gen = 1; q->fl[0].gen = q->fl[1].gen = 1;
q->fl[0].size = p->fl_size; q->fl[0].size = p->fl_size;

16
drivers/net/ethernet/chelsio/cxgb4/sge.c
View file

@ -2660,15 +2660,15 @@ static int ctrl_xmit(struct sge_ctrl_txq *q, struct sk_buff *skb)
/** /**
* restart_ctrlq - restart a suspended control queue * restart_ctrlq - restart a suspended control queue
* @data: the control queue to restart * @t: pointer to the tasklet associated with this handler
* *
* Resumes transmission on a suspended Tx control queue. * Resumes transmission on a suspended Tx control queue.
*/ */
static void restart_ctrlq(unsigned long data) static void restart_ctrlq(struct tasklet_struct *t)
{ {
struct sk_buff *skb; struct sk_buff *skb;
unsigned int written = 0; unsigned int written = 0;
struct sge_ctrl_txq *q = (struct sge_ctrl_txq *)data; struct sge_ctrl_txq *q = from_tasklet(q, t, qresume_tsk);
spin_lock(&q->sendq.lock); spin_lock(&q->sendq.lock);
reclaim_completed_tx_imm(&q->q); reclaim_completed_tx_imm(&q->q);
@ -2961,13 +2961,13 @@ static int ofld_xmit(struct sge_uld_txq *q, struct sk_buff *skb)
/** /**
* restart_ofldq - restart a suspended offload queue * restart_ofldq - restart a suspended offload queue
* @data: the offload queue to restart * @t: pointer to the tasklet associated with this handler
* *
* Resumes transmission on a suspended Tx offload queue. * Resumes transmission on a suspended Tx offload queue.
*/ */
static void restart_ofldq(unsigned long data) static void restart_ofldq(struct tasklet_struct *t)
{ {
struct sge_uld_txq *q = (struct sge_uld_txq *)data; struct sge_uld_txq *q = from_tasklet(q, t, qresume_tsk);
spin_lock(&q->sendq.lock); spin_lock(&q->sendq.lock);
q->full = 0; /* the queue actually is completely empty now */ q->full = 0; /* the queue actually is completely empty now */
@ -4580,7 +4580,7 @@ int t4_sge_alloc_ctrl_txq(struct adapter *adap, struct sge_ctrl_txq *txq,
init_txq(adap, &txq->q, FW_EQ_CTRL_CMD_EQID_G(ntohl(c.cmpliqid_eqid))); init_txq(adap, &txq->q, FW_EQ_CTRL_CMD_EQID_G(ntohl(c.cmpliqid_eqid)));
txq->adap = adap; txq->adap = adap;
skb_queue_head_init(&txq->sendq); skb_queue_head_init(&txq->sendq);
tasklet_init(&txq->qresume_tsk, restart_ctrlq, (unsigned long)txq); tasklet_setup(&txq->qresume_tsk, restart_ctrlq);
txq->full = 0; txq->full = 0;
return 0; return 0;
} }
@ -4670,7 +4670,7 @@ int t4_sge_alloc_uld_txq(struct adapter *adap, struct sge_uld_txq *txq,
txq->q.q_type = CXGB4_TXQ_ULD; txq->q.q_type = CXGB4_TXQ_ULD;
txq->adap = adap; txq->adap = adap;
skb_queue_head_init(&txq->sendq); skb_queue_head_init(&txq->sendq);
tasklet_init(&txq->qresume_tsk, restart_ofldq, (unsigned long)txq); tasklet_setup(&txq->qresume_tsk, restart_ofldq);
txq->full = 0; txq->full = 0;
txq->mapping_err = 0; txq->mapping_err = 0;
return 0; return 0;

21
drivers/net/ethernet/dlink/sundance.c
View file

@ -367,6 +367,7 @@ struct netdev_private {
dma_addr_t tx_ring_dma; dma_addr_t tx_ring_dma;
dma_addr_t rx_ring_dma; dma_addr_t rx_ring_dma;
struct timer_list timer; /* Media monitoring timer. */ struct timer_list timer; /* Media monitoring timer. */
struct net_device *ndev; /* backpointer */
/* ethtool extra stats */ /* ethtool extra stats */
struct { struct {
u64 tx_multiple_collisions; u64 tx_multiple_collisions;
@ -429,8 +430,8 @@ static void init_ring(struct net_device *dev);
static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev); static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
static int reset_tx (struct net_device *dev); static int reset_tx (struct net_device *dev);
static irqreturn_t intr_handler(int irq, void *dev_instance); static irqreturn_t intr_handler(int irq, void *dev_instance);
static void rx_poll(unsigned long data); static void rx_poll(struct tasklet_struct *t);
static void tx_poll(unsigned long data); static void tx_poll(struct tasklet_struct *t);
static void refill_rx (struct net_device *dev); static void refill_rx (struct net_device *dev);
static void netdev_error(struct net_device *dev, int intr_status); static void netdev_error(struct net_device *dev, int intr_status);
static void netdev_error(struct net_device *dev, int intr_status); static void netdev_error(struct net_device *dev, int intr_status);
@ -531,14 +532,15 @@ static int sundance_probe1(struct pci_dev *pdev,
cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET)); cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
np = netdev_priv(dev); np = netdev_priv(dev);
np->ndev = dev;
np->base = ioaddr; np->base = ioaddr;
np->pci_dev = pdev; np->pci_dev = pdev;
np->chip_id = chip_idx; np->chip_id = chip_idx;
np->msg_enable = (1 << debug) - 1; np->msg_enable = (1 << debug) - 1;
spin_lock_init(&np->lock); spin_lock_init(&np->lock);
spin_lock_init(&np->statlock); spin_lock_init(&np->statlock);
tasklet_init(&np->rx_tasklet, rx_poll, (unsigned long)dev); tasklet_setup(&np->rx_tasklet, rx_poll);
tasklet_init(&np->tx_tasklet, tx_poll, (unsigned long)dev); tasklet_setup(&np->tx_tasklet, tx_poll);
ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE, ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE,
&ring_dma, GFP_KERNEL); &ring_dma, GFP_KERNEL);
@ -1054,10 +1056,9 @@ static void init_ring(struct net_device *dev)
} }
} }
static void tx_poll (unsigned long data) static void tx_poll(struct tasklet_struct *t)
{ {
struct net_device *dev = (struct net_device *)data; struct netdev_private *np = from_tasklet(np, t, tx_tasklet);
struct netdev_private *np = netdev_priv(dev);
unsigned head = np->cur_task % TX_RING_SIZE; unsigned head = np->cur_task % TX_RING_SIZE;
struct netdev_desc *txdesc = struct netdev_desc *txdesc =
&np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE]; &np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE];
@ -1312,10 +1313,10 @@ static irqreturn_t intr_handler(int irq, void *dev_instance)
return IRQ_RETVAL(handled); return IRQ_RETVAL(handled);
} }
static void rx_poll(unsigned long data) static void rx_poll(struct tasklet_struct *t)
{ {
struct net_device *dev = (struct net_device *)data; struct netdev_private *np = from_tasklet(np, t, rx_tasklet);
struct netdev_private *np = netdev_priv(dev); struct net_device *dev = np->ndev;
int entry = np->cur_rx % RX_RING_SIZE; int entry = np->cur_rx % RX_RING_SIZE;
int boguscnt = np->budget; int boguscnt = np->budget;
void __iomem *ioaddr = np->base; void __iomem *ioaddr = np->base;

7
drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
View file

@ -370,9 +370,9 @@ static void eq_irq_work(struct work_struct *work)
* ceq_tasklet - the tasklet of the EQ that received the event * ceq_tasklet - the tasklet of the EQ that received the event
* @ceq_data: the eq * @ceq_data: the eq
**/ **/
static void ceq_tasklet(unsigned long ceq_data) static void ceq_tasklet(struct tasklet_struct *t)
{ {
struct hinic_eq *ceq = (struct hinic_eq *)ceq_data; struct hinic_eq *ceq = from_tasklet(ceq, t, ceq_tasklet);
eq_irq_handler(ceq); eq_irq_handler(ceq);
} }
@ -782,8 +782,7 @@ static int init_eq(struct hinic_eq *eq, struct hinic_hwif *hwif,
INIT_WORK(&aeq_work->work, eq_irq_work); INIT_WORK(&aeq_work->work, eq_irq_work);
} else if (type == HINIC_CEQ) { } else if (type == HINIC_CEQ) {
tasklet_init(&eq->ceq_tasklet, ceq_tasklet, tasklet_setup(&eq->ceq_tasklet, ceq_tasklet);
(unsigned long)eq);
} }
/* set the attributes of the msix entry */ /* set the attributes of the msix entry */

7
drivers/net/ethernet/ibm/ehea/ehea_main.c
View file

@ -1212,9 +1212,9 @@ static void ehea_parse_eqe(struct ehea_adapter *adapter, u64 eqe)
} }
} }
static void ehea_neq_tasklet(unsigned long data) static void ehea_neq_tasklet(struct tasklet_struct *t)
{ {
struct ehea_adapter *adapter = (struct ehea_adapter *)data; struct ehea_adapter *adapter = from_tasklet(adapter, t, neq_tasklet);
struct ehea_eqe *eqe; struct ehea_eqe *eqe;
u64 event_mask; u64 event_mask;
@ -3417,8 +3417,7 @@ static int ehea_probe_adapter(struct platform_device *dev)
goto out_free_ad; goto out_free_ad;
} }
tasklet_init(&adapter->neq_tasklet, ehea_neq_tasklet, tasklet_setup(&adapter->neq_tasklet, ehea_neq_tasklet);
(unsigned long)adapter);
ret = ehea_create_device_sysfs(dev); ret = ehea_create_device_sysfs(dev);
if (ret) if (ret)

7
drivers/net/ethernet/ibm/ibmvnic.c
View file

@ -4842,9 +4842,9 @@ static irqreturn_t ibmvnic_interrupt(int irq, void *instance)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void ibmvnic_tasklet(void *data) static void ibmvnic_tasklet(struct tasklet_struct *t)
{ {
struct ibmvnic_adapter *adapter = data; struct ibmvnic_adapter *adapter = from_tasklet(adapter, t, tasklet);
struct ibmvnic_crq_queue *queue = &adapter->crq; struct ibmvnic_crq_queue *queue = &adapter->crq;
union ibmvnic_crq *crq; union ibmvnic_crq *crq;
unsigned long flags; unsigned long flags;
@ -4979,8 +4979,7 @@ static int init_crq_queue(struct ibmvnic_adapter *adapter)
retrc = 0; retrc = 0;
tasklet_init(&adapter->tasklet, (void *)ibmvnic_tasklet, tasklet_setup(&adapter->tasklet, (void *)ibmvnic_tasklet);
(unsigned long)adapter);
netdev_dbg(adapter->netdev, "registering irq 0x%x\n", vdev->irq); netdev_dbg(adapter->netdev, "registering irq 0x%x\n", vdev->irq);
snprintf(crq->name, sizeof(crq->name), "ibmvnic-%x", snprintf(crq->name, sizeof(crq->name), "ibmvnic-%x",

40
drivers/net/ethernet/jme.c
View file

@ -1187,9 +1187,9 @@ jme_shutdown_nic(struct jme_adapter *jme)
} }
static void static void
jme_pcc_tasklet(unsigned long arg) jme_pcc_tasklet(struct tasklet_struct *t)
{ {
struct jme_adapter *jme = (struct jme_adapter *)arg; struct jme_adapter *jme = from_tasklet(jme, t, pcc_task);
struct net_device *netdev = jme->dev; struct net_device *netdev = jme->dev;
if (unlikely(test_bit(JME_FLAG_SHUTDOWN, &jme->flags))) { if (unlikely(test_bit(JME_FLAG_SHUTDOWN, &jme->flags))) {
@ -1265,10 +1265,9 @@ jme_stop_shutdown_timer(struct jme_adapter *jme)
jwrite32f(jme, JME_APMC, apmc); jwrite32f(jme, JME_APMC, apmc);
} }
static void static void jme_link_change_tasklet(struct tasklet_struct *t)
jme_link_change_tasklet(unsigned long arg)
{ {
struct jme_adapter *jme = (struct jme_adapter *)arg; struct jme_adapter *jme = from_tasklet(jme, t, linkch_task);
struct net_device *netdev = jme->dev; struct net_device *netdev = jme->dev;
int rc; int rc;
@ -1345,9 +1344,9 @@ jme_link_change_tasklet(unsigned long arg)
} }
static void static void
jme_rx_clean_tasklet(unsigned long arg) jme_rx_clean_tasklet(struct tasklet_struct *t)
{ {
struct jme_adapter *jme = (struct jme_adapter *)arg; struct jme_adapter *jme = from_tasklet(jme, t, rxclean_task);
struct dynpcc_info *dpi = &(jme->dpi); struct dynpcc_info *dpi = &(jme->dpi);
jme_process_receive(jme, jme->rx_ring_size); jme_process_receive(jme, jme->rx_ring_size);
@ -1380,9 +1379,9 @@ jme_poll(JME_NAPI_HOLDER(holder), JME_NAPI_WEIGHT(budget))
} }
static void static void
jme_rx_empty_tasklet(unsigned long arg) jme_rx_empty_tasklet(struct tasklet_struct *t)
{ {
struct jme_adapter *jme = (struct jme_adapter *)arg; struct jme_adapter *jme = from_tasklet(jme, t, rxempty_task);
if (unlikely(atomic_read(&jme->link_changing) != 1)) if (unlikely(atomic_read(&jme->link_changing) != 1))
return; return;
@ -1392,7 +1391,7 @@ jme_rx_empty_tasklet(unsigned long arg)
netif_info(jme, rx_status, jme->dev, "RX Queue Full!\n"); netif_info(jme, rx_status, jme->dev, "RX Queue Full!\n");
jme_rx_clean_tasklet(arg); jme_rx_clean_tasklet(&jme->rxclean_task);
while (atomic_read(&jme->rx_empty) > 0) { while (atomic_read(&jme->rx_empty) > 0) {
atomic_dec(&jme->rx_empty); atomic_dec(&jme->rx_empty);
@ -1416,10 +1415,9 @@ jme_wake_queue_if_stopped(struct jme_adapter *jme)
} }
static void static void jme_tx_clean_tasklet(struct tasklet_struct *t)
jme_tx_clean_tasklet(unsigned long arg)
{ {
struct jme_adapter *jme = (struct jme_adapter *)arg; struct jme_adapter *jme = from_tasklet(jme, t, txclean_task);
struct jme_ring *txring = &(jme->txring[0]); struct jme_ring *txring = &(jme->txring[0]);
struct txdesc *txdesc = txring->desc; struct txdesc *txdesc = txring->desc;
struct jme_buffer_info *txbi = txring->bufinf, *ctxbi, *ttxbi; struct jme_buffer_info *txbi = txring->bufinf, *ctxbi, *ttxbi;
@ -1834,14 +1832,10 @@ jme_open(struct net_device *netdev)
jme_clear_pm_disable_wol(jme); jme_clear_pm_disable_wol(jme);
JME_NAPI_ENABLE(jme); JME_NAPI_ENABLE(jme);
tasklet_init(&jme->linkch_task, jme_link_change_tasklet, tasklet_setup(&jme->linkch_task, jme_link_change_tasklet);
(unsigned long) jme); tasklet_setup(&jme->txclean_task, jme_tx_clean_tasklet);
tasklet_init(&jme->txclean_task, jme_tx_clean_tasklet, tasklet_setup(&jme->rxclean_task, jme_rx_clean_tasklet);
(unsigned long) jme); tasklet_setup(&jme->rxempty_task, jme_rx_empty_tasklet);
tasklet_init(&jme->rxclean_task, jme_rx_clean_tasklet,
(unsigned long) jme);
tasklet_init(&jme->rxempty_task, jme_rx_empty_tasklet,
(unsigned long) jme);
rc = jme_request_irq(jme); rc = jme_request_irq(jme);
if (rc) if (rc)
@ -3040,9 +3034,7 @@ jme_init_one(struct pci_dev *pdev,
atomic_set(&jme->tx_cleaning, 1); atomic_set(&jme->tx_cleaning, 1);
atomic_set(&jme->rx_empty, 1); atomic_set(&jme->rx_empty, 1);
tasklet_init(&jme->pcc_task, tasklet_setup(&jme->pcc_task, jme_pcc_tasklet);
jme_pcc_tasklet,
(unsigned long) jme);
jme->dpi.cur = PCC_P1; jme->dpi.cur = PCC_P1;
jme->reg_ghc = 0; jme->reg_ghc = 0;

6
drivers/net/ethernet/marvell/skge.c
View file

@ -3338,9 +3338,9 @@ static void skge_error_irq(struct skge_hw *hw)
* because accessing phy registers requires spin wait which might * because accessing phy registers requires spin wait which might
* cause excess interrupt latency. * cause excess interrupt latency.
*/ */
static void skge_extirq(unsigned long arg) static void skge_extirq(struct tasklet_struct *t)
{ {
struct skge_hw *hw = (struct skge_hw *) arg; struct skge_hw *hw = from_tasklet(hw, t, phy_task);
int port; int port;
for (port = 0; port < hw->ports; port++) { for (port = 0; port < hw->ports; port++) {
@ -3927,7 +3927,7 @@ static int skge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
hw->pdev = pdev; hw->pdev = pdev;
spin_lock_init(&hw->hw_lock); spin_lock_init(&hw->hw_lock);
spin_lock_init(&hw->phy_lock); spin_lock_init(&hw->phy_lock);
tasklet_init(&hw->phy_task, skge_extirq, (unsigned long) hw); tasklet_setup(&hw->phy_task, skge_extirq);
hw->regs = ioremap(pci_resource_start(pdev, 0), 0x4000); hw->regs = ioremap(pci_resource_start(pdev, 0), 0x4000);
if (!hw->regs) { if (!hw->regs) {

4
drivers/net/ethernet/mellanox/mlx4/cq.c
View file

@ -55,11 +55,11 @@
#define TASKLET_MAX_TIME 2 #define TASKLET_MAX_TIME 2
#define TASKLET_MAX_TIME_JIFFIES msecs_to_jiffies(TASKLET_MAX_TIME) #define TASKLET_MAX_TIME_JIFFIES msecs_to_jiffies(TASKLET_MAX_TIME)
void mlx4_cq_tasklet_cb(unsigned long data) void mlx4_cq_tasklet_cb(struct tasklet_struct *t)
{ {
unsigned long flags; unsigned long flags;
unsigned long end = jiffies + TASKLET_MAX_TIME_JIFFIES; unsigned long end = jiffies + TASKLET_MAX_TIME_JIFFIES;
struct mlx4_eq_tasklet *ctx = (struct mlx4_eq_tasklet *)data; struct mlx4_eq_tasklet *ctx = from_tasklet(ctx, t, task);
struct mlx4_cq *mcq, *temp; struct mlx4_cq *mcq, *temp;
spin_lock_irqsave(&ctx->lock, flags); spin_lock_irqsave(&ctx->lock, flags);

3
drivers/net/ethernet/mellanox/mlx4/eq.c
View file

@ -1057,8 +1057,7 @@ static int mlx4_create_eq(struct mlx4_dev *dev, int nent,
INIT_LIST_HEAD(&eq->tasklet_ctx.list); INIT_LIST_HEAD(&eq->tasklet_ctx.list);
INIT_LIST_HEAD(&eq->tasklet_ctx.process_list); INIT_LIST_HEAD(&eq->tasklet_ctx.process_list);
spin_lock_init(&eq->tasklet_ctx.lock); spin_lock_init(&eq->tasklet_ctx.lock);
tasklet_init(&eq->tasklet_ctx.task, mlx4_cq_tasklet_cb, tasklet_setup(&eq->tasklet_ctx.task, mlx4_cq_tasklet_cb);
(unsigned long)&eq->tasklet_ctx);
return err; return err;

2
drivers/net/ethernet/mellanox/mlx4/mlx4.h
View file

@ -1217,7 +1217,7 @@ void mlx4_cmd_use_polling(struct mlx4_dev *dev);
int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param, int mlx4_comm_cmd(struct mlx4_dev *dev, u8 cmd, u16 param,
u16 op, unsigned long timeout); u16 op, unsigned long timeout);
void mlx4_cq_tasklet_cb(unsigned long data); void mlx4_cq_tasklet_cb(struct tasklet_struct *t);
void mlx4_cq_completion(struct mlx4_dev *dev, u32 cqn); void mlx4_cq_completion(struct mlx4_dev *dev, u32 cqn);
void mlx4_cq_event(struct mlx4_dev *dev, u32 cqn, int event_type); void mlx4_cq_event(struct mlx4_dev *dev, u32 cqn, int event_type);

4
drivers/net/ethernet/mellanox/mlx5/core/cq.c
View file

@ -42,11 +42,11 @@
#define TASKLET_MAX_TIME 2 #define TASKLET_MAX_TIME 2
#define TASKLET_MAX_TIME_JIFFIES msecs_to_jiffies(TASKLET_MAX_TIME) #define TASKLET_MAX_TIME_JIFFIES msecs_to_jiffies(TASKLET_MAX_TIME)
void mlx5_cq_tasklet_cb(unsigned long data) void mlx5_cq_tasklet_cb(struct tasklet_struct *t)
{ {
unsigned long flags; unsigned long flags;
unsigned long end = jiffies + TASKLET_MAX_TIME_JIFFIES; unsigned long end = jiffies + TASKLET_MAX_TIME_JIFFIES;
struct mlx5_eq_tasklet *ctx = (struct mlx5_eq_tasklet *)data; struct mlx5_eq_tasklet *ctx = from_tasklet(ctx, t, task);
struct mlx5_core_cq *mcq; struct mlx5_core_cq *mcq;
struct mlx5_core_cq *temp; struct mlx5_core_cq *temp;

3
drivers/net/ethernet/mellanox/mlx5/core/eq.c
View file

@ -788,8 +788,7 @@ static int create_comp_eqs(struct mlx5_core_dev *dev)
INIT_LIST_HEAD(&eq->tasklet_ctx.list); INIT_LIST_HEAD(&eq->tasklet_ctx.list);
INIT_LIST_HEAD(&eq->tasklet_ctx.process_list); INIT_LIST_HEAD(&eq->tasklet_ctx.process_list);
spin_lock_init(&eq->tasklet_ctx.lock); spin_lock_init(&eq->tasklet_ctx.lock);
tasklet_init(&eq->tasklet_ctx.task, mlx5_cq_tasklet_cb, tasklet_setup(&eq->tasklet_ctx.task, mlx5_cq_tasklet_cb);
(unsigned long)&eq->tasklet_ctx);
eq->irq_nb.notifier_call = mlx5_eq_comp_int; eq->irq_nb.notifier_call = mlx5_eq_comp_int;
param = (struct mlx5_eq_param) { param = (struct mlx5_eq_param) {

7
drivers/net/ethernet/mellanox/mlx5/core/fpga/conn.c
View file

@ -388,9 +388,9 @@ static inline void mlx5_fpga_conn_cqes(struct mlx5_fpga_conn *conn,
mlx5_fpga_conn_arm_cq(conn); mlx5_fpga_conn_arm_cq(conn);
} }
static void mlx5_fpga_conn_cq_tasklet(unsigned long data) static void mlx5_fpga_conn_cq_tasklet(struct tasklet_struct *t)
{ {
struct mlx5_fpga_conn *conn = (void *)data; struct mlx5_fpga_conn *conn = from_tasklet(conn, t, cq.tasklet);
if (unlikely(!conn->qp.active)) if (unlikely(!conn->qp.active))
return; return;
@ -478,8 +478,7 @@ static int mlx5_fpga_conn_create_cq(struct mlx5_fpga_conn *conn, int cq_size)
conn->cq.mcq.comp = mlx5_fpga_conn_cq_complete; conn->cq.mcq.comp = mlx5_fpga_conn_cq_complete;
conn->cq.mcq.irqn = irqn; conn->cq.mcq.irqn = irqn;
conn->cq.mcq.uar = fdev->conn_res.uar; conn->cq.mcq.uar = fdev->conn_res.uar;
tasklet_init(&conn->cq.tasklet, mlx5_fpga_conn_cq_tasklet, tasklet_setup(&conn->cq.tasklet, mlx5_fpga_conn_cq_tasklet);
(unsigned long)conn);
mlx5_fpga_dbg(fdev, "Created CQ #0x%x\n", conn->cq.mcq.cqn); mlx5_fpga_dbg(fdev, "Created CQ #0x%x\n", conn->cq.mcq.cqn);

2
drivers/net/ethernet/mellanox/mlx5/core/lib/eq.h
View file

@ -77,7 +77,7 @@ int mlx5_eq_add_cq(struct mlx5_eq *eq, struct mlx5_core_cq *cq);
void mlx5_eq_del_cq(struct mlx5_eq *eq, struct mlx5_core_cq *cq); void mlx5_eq_del_cq(struct mlx5_eq *eq, struct mlx5_core_cq *cq);
struct mlx5_eq_comp *mlx5_eqn2comp_eq(struct mlx5_core_dev *dev, int eqn); struct mlx5_eq_comp *mlx5_eqn2comp_eq(struct mlx5_core_dev *dev, int eqn);
struct mlx5_eq *mlx5_get_async_eq(struct mlx5_core_dev *dev); struct mlx5_eq *mlx5_get_async_eq(struct mlx5_core_dev *dev);
void mlx5_cq_tasklet_cb(unsigned long data); void mlx5_cq_tasklet_cb(struct tasklet_struct *t);
struct cpumask *mlx5_eq_comp_cpumask(struct mlx5_core_dev *dev, int ix); struct cpumask *mlx5_eq_comp_cpumask(struct mlx5_core_dev *dev, int ix);
u32 mlx5_eq_poll_irq_disabled(struct mlx5_eq_comp *eq); u32 mlx5_eq_poll_irq_disabled(struct mlx5_eq_comp *eq);

12
drivers/net/ethernet/mellanox/mlxsw/pci.c
View file

@ -620,9 +620,9 @@ static char *mlxsw_pci_cq_sw_cqe_get(struct mlxsw_pci_queue *q)
return elem; return elem;
} }
static void mlxsw_pci_cq_tasklet(unsigned long data) static void mlxsw_pci_cq_tasklet(struct tasklet_struct *t)
{ {
struct mlxsw_pci_queue *q = (struct mlxsw_pci_queue *) data; struct mlxsw_pci_queue *q = from_tasklet(q, t, tasklet);
struct mlxsw_pci *mlxsw_pci = q->pci; struct mlxsw_pci *mlxsw_pci = q->pci;
char *cqe; char *cqe;
int items = 0; int items = 0;
@ -733,9 +733,9 @@ static char *mlxsw_pci_eq_sw_eqe_get(struct mlxsw_pci_queue *q)
return elem; return elem;
} }
static void mlxsw_pci_eq_tasklet(unsigned long data) static void mlxsw_pci_eq_tasklet(struct tasklet_struct *t)
{ {
struct mlxsw_pci_queue *q = (struct mlxsw_pci_queue *) data; struct mlxsw_pci_queue *q = from_tasklet(q, t, tasklet);
struct mlxsw_pci *mlxsw_pci = q->pci; struct mlxsw_pci *mlxsw_pci = q->pci;
u8 cq_count = mlxsw_pci_cq_count(mlxsw_pci); u8 cq_count = mlxsw_pci_cq_count(mlxsw_pci);
unsigned long active_cqns[BITS_TO_LONGS(MLXSW_PCI_CQS_MAX)]; unsigned long active_cqns[BITS_TO_LONGS(MLXSW_PCI_CQS_MAX)];
@ -792,7 +792,7 @@ struct mlxsw_pci_queue_ops {
struct mlxsw_pci_queue *q); struct mlxsw_pci_queue *q);
void (*fini)(struct mlxsw_pci *mlxsw_pci, void (*fini)(struct mlxsw_pci *mlxsw_pci,
struct mlxsw_pci_queue *q); struct mlxsw_pci_queue *q);
void (*tasklet)(unsigned long data); void (*tasklet)(struct tasklet_struct *t);
u16 (*elem_count_f)(const struct mlxsw_pci_queue *q); u16 (*elem_count_f)(const struct mlxsw_pci_queue *q);
u8 (*elem_size_f)(const struct mlxsw_pci_queue *q); u8 (*elem_size_f)(const struct mlxsw_pci_queue *q);
u16 elem_count; u16 elem_count;
@ -855,7 +855,7 @@ static int mlxsw_pci_queue_init(struct mlxsw_pci *mlxsw_pci, char *mbox,
q->pci = mlxsw_pci; q->pci = mlxsw_pci;
if (q_ops->tasklet) if (q_ops->tasklet)
tasklet_init(&q->tasklet, q_ops->tasklet, (unsigned long) q); tasklet_setup(&q->tasklet, q_ops->tasklet);
mem_item->size = MLXSW_PCI_AQ_SIZE; mem_item->size = MLXSW_PCI_AQ_SIZE;
mem_item->buf = pci_alloc_consistent(mlxsw_pci->pdev, mem_item->buf = pci_alloc_consistent(mlxsw_pci->pdev,

17
drivers/net/ethernet/micrel/ks8842.c
View file

@ -587,10 +587,10 @@ static int __ks8842_start_new_rx_dma(struct net_device *netdev)
return err; return err;
} }
static void ks8842_rx_frame_dma_tasklet(unsigned long arg) static void ks8842_rx_frame_dma_tasklet(struct tasklet_struct *t)
{ {
struct net_device *netdev = (struct net_device *)arg; struct ks8842_adapter *adapter = from_tasklet(adapter, t, dma_rx.tasklet);
struct ks8842_adapter *adapter = netdev_priv(netdev); struct net_device *netdev = adapter->netdev;
struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx; struct ks8842_rx_dma_ctl *ctl = &adapter->dma_rx;
struct sk_buff *skb = ctl->skb; struct sk_buff *skb = ctl->skb;
dma_addr_t addr = sg_dma_address(&ctl->sg); dma_addr_t addr = sg_dma_address(&ctl->sg);
@ -720,10 +720,10 @@ static void ks8842_handle_rx_overrun(struct net_device *netdev,
netdev->stats.rx_fifo_errors++; netdev->stats.rx_fifo_errors++;
} }
static void ks8842_tasklet(unsigned long arg) static void ks8842_tasklet(struct tasklet_struct *t)
{ {
struct net_device *netdev = (struct net_device *)arg; struct ks8842_adapter *adapter = from_tasklet(adapter, t, tasklet);
struct ks8842_adapter *adapter = netdev_priv(netdev); struct net_device *netdev = adapter->netdev;
u16 isr; u16 isr;
unsigned long flags; unsigned long flags;
u16 entry_bank; u16 entry_bank;
@ -953,8 +953,7 @@ static int ks8842_alloc_dma_bufs(struct net_device *netdev)
goto err; goto err;
} }
tasklet_init(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet, tasklet_setup(&rx_ctl->tasklet, ks8842_rx_frame_dma_tasklet);
(unsigned long)netdev);
return 0; return 0;
err: err:
@ -1173,7 +1172,7 @@ static int ks8842_probe(struct platform_device *pdev)
adapter->dma_tx.channel = -1; adapter->dma_tx.channel = -1;
} }
tasklet_init(&adapter->tasklet, ks8842_tasklet, (unsigned long)netdev); tasklet_setup(&adapter->tasklet, ks8842_tasklet);
spin_lock_init(&adapter->lock); spin_lock_init(&adapter->lock);
netdev->netdev_ops = &ks8842_netdev_ops; netdev->netdev_ops = &ks8842_netdev_ops;

14
drivers/net/ethernet/micrel/ksz884x.c
View file

@ -5159,9 +5159,9 @@ static int dev_rcv_special(struct dev_info *hw_priv)
return received; return received;
} }
static void rx_proc_task(unsigned long data) static void rx_proc_task(struct tasklet_struct *t)
{ {
struct dev_info *hw_priv = (struct dev_info *) data; struct dev_info *hw_priv = from_tasklet(hw_priv, t, rx_tasklet);
struct ksz_hw *hw = &hw_priv->hw; struct ksz_hw *hw = &hw_priv->hw;
if (!hw->enabled) if (!hw->enabled)
@ -5181,9 +5181,9 @@ static void rx_proc_task(unsigned long data)
} }
} }
static void tx_proc_task(unsigned long data) static void tx_proc_task(struct tasklet_struct *t)
{ {
struct dev_info *hw_priv = (struct dev_info *) data; struct dev_info *hw_priv = from_tasklet(hw_priv, t, tx_tasklet);
struct ksz_hw *hw = &hw_priv->hw; struct ksz_hw *hw = &hw_priv->hw;
hw_ack_intr(hw, KS884X_INT_TX_MASK); hw_ack_intr(hw, KS884X_INT_TX_MASK);
@ -5436,10 +5436,8 @@ static int prepare_hardware(struct net_device *dev)
rc = request_irq(dev->irq, netdev_intr, IRQF_SHARED, dev->name, dev); rc = request_irq(dev->irq, netdev_intr, IRQF_SHARED, dev->name, dev);
if (rc) if (rc)
return rc; return rc;
tasklet_init(&hw_priv->rx_tasklet, rx_proc_task, tasklet_setup(&hw_priv->rx_tasklet, rx_proc_task);
(unsigned long) hw_priv); tasklet_setup(&hw_priv->tx_tasklet, tx_proc_task);
tasklet_init(&hw_priv->tx_tasklet, tx_proc_task,
(unsigned long) hw_priv);
hw->promiscuous = 0; hw->promiscuous = 0;
hw->all_multi = 0; hw->all_multi = 0;

8
drivers/net/ethernet/natsemi/ns83820.c
View file

@ -923,10 +923,10 @@ static void rx_irq(struct net_device *ndev)
spin_unlock_irqrestore(&info->lock, flags); spin_unlock_irqrestore(&info->lock, flags);
} }
static void rx_action(unsigned long _dev) static void rx_action(struct tasklet_struct *t)
{ {
struct net_device *ndev = (void *)_dev; struct ns83820 *dev = from_tasklet(dev, t, rx_tasklet);
struct ns83820 *dev = PRIV(ndev); struct net_device *ndev = dev->ndev;
rx_irq(ndev); rx_irq(ndev);
writel(ihr, dev->base + IHR); writel(ihr, dev->base + IHR);
@ -1924,7 +1924,7 @@ static int ns83820_init_one(struct pci_dev *pci_dev,
SET_NETDEV_DEV(ndev, &pci_dev->dev); SET_NETDEV_DEV(ndev, &pci_dev->dev);
INIT_WORK(&dev->tq_refill, queue_refill); INIT_WORK(&dev->tq_refill, queue_refill);
tasklet_init(&dev->rx_tasklet, rx_action, (unsigned long)ndev); tasklet_setup(&dev->rx_tasklet, rx_action);
err = pci_enable_device(pci_dev); err = pci_enable_device(pci_dev);
if (err) { if (err) {

7
drivers/net/ethernet/netronome/nfp/nfp_net_common.c
View file

@ -2287,9 +2287,9 @@ static bool nfp_ctrl_rx(struct nfp_net_r_vector *r_vec)
return budget; return budget;
} }
static void nfp_ctrl_poll(unsigned long arg) static void nfp_ctrl_poll(struct tasklet_struct *t)
{ {
struct nfp_net_r_vector *r_vec = (void *)arg; struct nfp_net_r_vector *r_vec = from_tasklet(r_vec, t, tasklet);
spin_lock(&r_vec->lock); spin_lock(&r_vec->lock);
nfp_net_tx_complete(r_vec->tx_ring, 0); nfp_net_tx_complete(r_vec->tx_ring, 0);
@ -2337,8 +2337,7 @@ static void nfp_net_vecs_init(struct nfp_net *nn)
__skb_queue_head_init(&r_vec->queue); __skb_queue_head_init(&r_vec->queue);
spin_lock_init(&r_vec->lock); spin_lock_init(&r_vec->lock);
tasklet_init(&r_vec->tasklet, nfp_ctrl_poll, tasklet_setup(&r_vec->tasklet, nfp_ctrl_poll);
(unsigned long)r_vec);
tasklet_disable(&r_vec->tasklet); tasklet_disable(&r_vec->tasklet);
} }

7
drivers/net/ethernet/ni/nixge.c
View file

@ -787,9 +787,9 @@ static irqreturn_t nixge_rx_irq(int irq, void *_ndev)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void nixge_dma_err_handler(unsigned long data) static void nixge_dma_err_handler(struct tasklet_struct *t)
{ {
struct nixge_priv *lp = (struct nixge_priv *)data; struct nixge_priv *lp = from_tasklet(lp, t, dma_err_tasklet);
struct nixge_hw_dma_bd *cur_p; struct nixge_hw_dma_bd *cur_p;
struct nixge_tx_skb *tx_skb; struct nixge_tx_skb *tx_skb;
u32 cr, i; u32 cr, i;
@ -879,8 +879,7 @@ static int nixge_open(struct net_device *ndev)
phy_start(phy); phy_start(phy);
/* Enable tasklets for Axi DMA error handling */ /* Enable tasklets for Axi DMA error handling */
tasklet_init(&priv->dma_err_tasklet, nixge_dma_err_handler, tasklet_setup(&priv->dma_err_tasklet, nixge_dma_err_handler);
(unsigned long)priv);
napi_enable(&priv->napi); napi_enable(&priv->napi);

2
drivers/net/ethernet/qlogic/qed/qed.h
View file

@ -572,7 +572,7 @@ struct qed_hwfn {
struct qed_consq *p_consq; struct qed_consq *p_consq;
/* Slow-Path definitions */ /* Slow-Path definitions */
struct tasklet_struct *sp_dpc; struct tasklet_struct sp_dpc;
bool b_sp_dpc_enabled; bool b_sp_dpc_enabled;
struct qed_ptt *p_main_ptt; struct qed_ptt *p_main_ptt;

27
drivers/net/ethernet/qlogic/qed/qed_int.c
View file

@ -1216,9 +1216,9 @@ static void qed_sb_ack_attn(struct qed_hwfn *p_hwfn,
barrier(); barrier();
} }
void qed_int_sp_dpc(unsigned long hwfn_cookie) void qed_int_sp_dpc(struct tasklet_struct *t)
{ {
struct qed_hwfn *p_hwfn = (struct qed_hwfn *)hwfn_cookie; struct qed_hwfn *p_hwfn = from_tasklet(p_hwfn, t, sp_dpc);
struct qed_pi_info *pi_info = NULL; struct qed_pi_info *pi_info = NULL;
struct qed_sb_attn_info *sb_attn; struct qed_sb_attn_info *sb_attn;
struct qed_sb_info *sb_info; struct qed_sb_info *sb_info;
@ -2285,34 +2285,14 @@ u64 qed_int_igu_read_sisr_reg(struct qed_hwfn *p_hwfn)
static void qed_int_sp_dpc_setup(struct qed_hwfn *p_hwfn) static void qed_int_sp_dpc_setup(struct qed_hwfn *p_hwfn)
{ {
tasklet_init(p_hwfn->sp_dpc, tasklet_setup(&p_hwfn->sp_dpc, qed_int_sp_dpc);
qed_int_sp_dpc, (unsigned long)p_hwfn);
p_hwfn->b_sp_dpc_enabled = true; p_hwfn->b_sp_dpc_enabled = true;
} }
static int qed_int_sp_dpc_alloc(struct qed_hwfn *p_hwfn)
{
p_hwfn->sp_dpc = kmalloc(sizeof(*p_hwfn->sp_dpc), GFP_KERNEL);
if (!p_hwfn->sp_dpc)
return -ENOMEM;
return 0;
}
static void qed_int_sp_dpc_free(struct qed_hwfn *p_hwfn)
{
kfree(p_hwfn->sp_dpc);
p_hwfn->sp_dpc = NULL;
}
int qed_int_alloc(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) int qed_int_alloc(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)
{ {
int rc = 0; int rc = 0;
rc = qed_int_sp_dpc_alloc(p_hwfn);
if (rc)
return rc;
rc = qed_int_sp_sb_alloc(p_hwfn, p_ptt); rc = qed_int_sp_sb_alloc(p_hwfn, p_ptt);
if (rc) if (rc)
return rc; return rc;
@ -2326,7 +2306,6 @@ void qed_int_free(struct qed_hwfn *p_hwfn)
{ {
qed_int_sp_sb_free(p_hwfn); qed_int_sp_sb_free(p_hwfn);
qed_int_sb_attn_free(p_hwfn); qed_int_sb_attn_free(p_hwfn);
qed_int_sp_dpc_free(p_hwfn);
} }
void qed_int_setup(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt) void qed_int_setup(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt)

2
drivers/net/ethernet/qlogic/qed/qed_int.h
View file

@ -140,7 +140,7 @@ int qed_int_sb_release(struct qed_hwfn *p_hwfn,
* @param p_hwfn - pointer to hwfn * @param p_hwfn - pointer to hwfn
* *
*/ */
void qed_int_sp_dpc(unsigned long hwfn_cookie); void qed_int_sp_dpc(struct tasklet_struct *t);
/** /**
* @brief qed_int_get_num_sbs - get the number of status * @brief qed_int_get_num_sbs - get the number of status

14
drivers/net/ethernet/qlogic/qed/qed_main.c
View file

@ -734,7 +734,7 @@ static irqreturn_t qed_single_int(int irq, void *dev_instance)
/* Slowpath interrupt */ /* Slowpath interrupt */
if (unlikely(status & 0x1)) { if (unlikely(status & 0x1)) {
tasklet_schedule(hwfn->sp_dpc); tasklet_schedule(&hwfn->sp_dpc);
status &= ~0x1; status &= ~0x1;
rc = IRQ_HANDLED; rc = IRQ_HANDLED;
} }
@ -780,7 +780,7 @@ int qed_slowpath_irq_req(struct qed_hwfn *hwfn)
id, cdev->pdev->bus->number, id, cdev->pdev->bus->number,
PCI_SLOT(cdev->pdev->devfn), hwfn->abs_pf_id); PCI_SLOT(cdev->pdev->devfn), hwfn->abs_pf_id);
rc = request_irq(cdev->int_params.msix_table[id].vector, rc = request_irq(cdev->int_params.msix_table[id].vector,
qed_msix_sp_int, 0, hwfn->name, hwfn->sp_dpc); qed_msix_sp_int, 0, hwfn->name, &hwfn->sp_dpc);
} else { } else {
unsigned long flags = 0; unsigned long flags = 0;
@ -812,8 +812,8 @@ static void qed_slowpath_tasklet_flush(struct qed_hwfn *p_hwfn)
* enable function makes this sequence a flush-like operation. * enable function makes this sequence a flush-like operation.
*/ */
if (p_hwfn->b_sp_dpc_enabled) { if (p_hwfn->b_sp_dpc_enabled) {
tasklet_disable(p_hwfn->sp_dpc); tasklet_disable(&p_hwfn->sp_dpc);
tasklet_enable(p_hwfn->sp_dpc); tasklet_enable(&p_hwfn->sp_dpc);
} }
} }
@ -842,7 +842,7 @@ static void qed_slowpath_irq_free(struct qed_dev *cdev)
break; break;
synchronize_irq(cdev->int_params.msix_table[i].vector); synchronize_irq(cdev->int_params.msix_table[i].vector);
free_irq(cdev->int_params.msix_table[i].vector, free_irq(cdev->int_params.msix_table[i].vector,
cdev->hwfns[i].sp_dpc); &cdev->hwfns[i].sp_dpc);
} }
} else { } else {
if (QED_LEADING_HWFN(cdev)->b_int_requested) if (QED_LEADING_HWFN(cdev)->b_int_requested)
@ -861,11 +861,11 @@ static int qed_nic_stop(struct qed_dev *cdev)
struct qed_hwfn *p_hwfn = &cdev->hwfns[i]; struct qed_hwfn *p_hwfn = &cdev->hwfns[i];
if (p_hwfn->b_sp_dpc_enabled) { if (p_hwfn->b_sp_dpc_enabled) {
tasklet_disable(p_hwfn->sp_dpc); tasklet_disable(&p_hwfn->sp_dpc);
p_hwfn->b_sp_dpc_enabled = false; p_hwfn->b_sp_dpc_enabled = false;
DP_VERBOSE(cdev, NETIF_MSG_IFDOWN, DP_VERBOSE(cdev, NETIF_MSG_IFDOWN,
"Disabled sp tasklet [hwfn %d] at %p\n", "Disabled sp tasklet [hwfn %d] at %p\n",
i, p_hwfn->sp_dpc); i, &p_hwfn->sp_dpc);
} }
} }

12
drivers/net/ethernet/silan/sc92031.c
View file

@ -301,6 +301,7 @@ struct sc92031_priv {
/* for dev->get_stats */ /* for dev->get_stats */
long rx_value; long rx_value;
struct net_device *ndev;
}; };
/* I don't know which registers can be safely read; however, I can guess /* I don't know which registers can be safely read; however, I can guess
@ -829,10 +830,10 @@ static void _sc92031_link_tasklet(struct net_device *dev)
} }
} }
static void sc92031_tasklet(unsigned long data) static void sc92031_tasklet(struct tasklet_struct *t)
{ {
struct net_device *dev = (struct net_device *)data; struct sc92031_priv *priv = from_tasklet(priv, t, tasklet);
struct sc92031_priv *priv = netdev_priv(dev); struct net_device *dev = priv->ndev;
void __iomem *port_base = priv->port_base; void __iomem *port_base = priv->port_base;
u32 intr_status, intr_mask; u32 intr_status, intr_mask;
@ -1108,7 +1109,7 @@ static void sc92031_poll_controller(struct net_device *dev)
disable_irq(irq); disable_irq(irq);
if (sc92031_interrupt(irq, dev) != IRQ_NONE) if (sc92031_interrupt(irq, dev) != IRQ_NONE)
sc92031_tasklet((unsigned long)dev); sc92031_tasklet(&priv->tasklet);
enable_irq(irq); enable_irq(irq);
} }
#endif #endif
@ -1443,10 +1444,11 @@ static int sc92031_probe(struct pci_dev *pdev, const struct pci_device_id *id)
dev->ethtool_ops = &sc92031_ethtool_ops; dev->ethtool_ops = &sc92031_ethtool_ops;
priv = netdev_priv(dev); priv = netdev_priv(dev);
priv->ndev = dev;
spin_lock_init(&priv->lock); spin_lock_init(&priv->lock);
priv->port_base = port_base; priv->port_base = port_base;
priv->pdev = pdev; priv->pdev = pdev;
tasklet_init(&priv->tasklet, sc92031_tasklet, (unsigned long)dev); tasklet_setup(&priv->tasklet, sc92031_tasklet);
/* Fudge tasklet count so the call to sc92031_enable_interrupts at /* Fudge tasklet count so the call to sc92031_enable_interrupts at
* sc92031_open will work correctly */ * sc92031_open will work correctly */
tasklet_disable_nosync(&priv->tasklet); tasklet_disable_nosync(&priv->tasklet);

10
drivers/net/ethernet/smsc/smc91x.c
View file

@ -535,10 +535,10 @@ static inline void smc_rcv(struct net_device *dev)
/* /*
* This is called to actually send a packet to the chip. * This is called to actually send a packet to the chip.
*/ */
static void smc_hardware_send_pkt(unsigned long data) static void smc_hardware_send_pkt(struct tasklet_struct *t)
{ {
struct net_device *dev = (struct net_device *)data; struct smc_local *lp = from_tasklet(lp, t, tx_task);
struct smc_local *lp = netdev_priv(dev); struct net_device *dev = lp->dev;
void __iomem *ioaddr = lp->base; void __iomem *ioaddr = lp->base;
struct sk_buff *skb; struct sk_buff *skb;
unsigned int packet_no, len; unsigned int packet_no, len;
@ -688,7 +688,7 @@ smc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
* Allocation succeeded: push packet to the chip's own memory * Allocation succeeded: push packet to the chip's own memory
* immediately. * immediately.
*/ */
smc_hardware_send_pkt((unsigned long)dev); smc_hardware_send_pkt(&lp->tx_task);
} }
return NETDEV_TX_OK; return NETDEV_TX_OK;
@ -1964,7 +1964,7 @@ static int smc_probe(struct net_device *dev, void __iomem *ioaddr,
dev->netdev_ops = &smc_netdev_ops; dev->netdev_ops = &smc_netdev_ops;
dev->ethtool_ops = &smc_ethtool_ops; dev->ethtool_ops = &smc_ethtool_ops;
tasklet_init(&lp->tx_task, smc_hardware_send_pkt, (unsigned long)dev); tasklet_setup(&lp->tx_task, smc_hardware_send_pkt);
INIT_WORK(&lp->phy_configure, smc_phy_configure); INIT_WORK(&lp->phy_configure, smc_phy_configure);
lp->dev = dev; lp->dev = dev;
lp->mii.phy_id_mask = 0x1f; lp->mii.phy_id_mask = 0x1f;