net: xgbe: Convert tasklet API to new bottom half workqueue mechanism

Migrate tasklet APIs to the new bottom half workqueue mechanism. It
replaces all occurrences of tasklet usage with the appropriate workqueue
APIs throughout the xgbe driver. This transition ensures compatibility
with the latest design and enhances performance.

Signed-off-by: Allen Pais <allen.lkml@gmail.com>
Link: https://patch.msgid.link/20240730183403.4176544-3-allen.lkml@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index c4a4e31..5475867 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -403,9 +403,9 @@ static bool xgbe_ecc_ded(struct xgbe_prv_data *pdata, unsigned long *period,
        return false;
 }
 
-static void xgbe_ecc_isr_task(struct tasklet_struct *t)
+static void xgbe_ecc_isr_bh_work(struct work_struct *work)
 {
-       struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_ecc);
+       struct xgbe_prv_data *pdata = from_work(pdata, work, ecc_bh_work);
        unsigned int ecc_isr;
        bool stop = false;
 
@@ -465,17 +465,17 @@ static irqreturn_t xgbe_ecc_isr(int irq, void *data)
 {
        struct xgbe_prv_data *pdata = data;
 
-       if (pdata->isr_as_tasklet)
-               tasklet_schedule(&pdata->tasklet_ecc);
+       if (pdata->isr_as_bh_work)
+               queue_work(system_bh_wq, &pdata->ecc_bh_work);
        else
-               xgbe_ecc_isr_task(&pdata->tasklet_ecc);
+               xgbe_ecc_isr_bh_work(&pdata->ecc_bh_work);
 
        return IRQ_HANDLED;
 }
 
-static void xgbe_isr_task(struct tasklet_struct *t)
+static void xgbe_isr_bh_work(struct work_struct *work)
 {
-       struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_dev);
+       struct xgbe_prv_data *pdata = from_work(pdata, work, dev_bh_work);
        struct xgbe_hw_if *hw_if = &pdata->hw_if;
        struct xgbe_channel *channel;
        unsigned int dma_isr, dma_ch_isr;
@@ -582,7 +582,7 @@ isr_done:
 
        /* If there is not a separate ECC irq, handle it here */
        if (pdata->vdata->ecc_support && (pdata->dev_irq == pdata->ecc_irq))
-               xgbe_ecc_isr_task(&pdata->tasklet_ecc);
+               xgbe_ecc_isr_bh_work(&pdata->ecc_bh_work);
 
        /* If there is not a separate I2C irq, handle it here */
        if (pdata->vdata->i2c_support && (pdata->dev_irq == pdata->i2c_irq))
@@ -604,10 +604,10 @@ static irqreturn_t xgbe_isr(int irq, void *data)
 {
        struct xgbe_prv_data *pdata = data;
 
-       if (pdata->isr_as_tasklet)
-               tasklet_schedule(&pdata->tasklet_dev);
+       if (pdata->isr_as_bh_work)
+               queue_work(system_bh_wq, &pdata->dev_bh_work);
        else
-               xgbe_isr_task(&pdata->tasklet_dev);
+               xgbe_isr_bh_work(&pdata->dev_bh_work);
 
        return IRQ_HANDLED;
 }
@@ -1007,8 +1007,8 @@ static int xgbe_request_irqs(struct xgbe_prv_data *pdata)
        unsigned int i;
        int ret;
 
-       tasklet_setup(&pdata->tasklet_dev, xgbe_isr_task);
-       tasklet_setup(&pdata->tasklet_ecc, xgbe_ecc_isr_task);
+       INIT_WORK(&pdata->dev_bh_work, xgbe_isr_bh_work);
+       INIT_WORK(&pdata->ecc_bh_work, xgbe_ecc_isr_bh_work);
 
        ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0,
                               netdev_name(netdev), pdata);
@@ -1078,8 +1078,8 @@ static void xgbe_free_irqs(struct xgbe_prv_data *pdata)
 
        devm_free_irq(pdata->dev, pdata->dev_irq, pdata);
 
-       tasklet_kill(&pdata->tasklet_dev);
-       tasklet_kill(&pdata->tasklet_ecc);
+       cancel_work_sync(&pdata->dev_bh_work);
+       cancel_work_sync(&pdata->ecc_bh_work);
 
        if (pdata->vdata->ecc_support && (pdata->dev_irq != pdata->ecc_irq))
                devm_free_irq(pdata->dev, pdata->ecc_irq, pdata);

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c b/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
index a9ccc42..7a83389 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
@@ -274,9 +274,9 @@ static void xgbe_i2c_clear_isr_interrupts(struct xgbe_prv_data *pdata,
                XI2C_IOREAD(pdata, IC_CLR_STOP_DET);
 }
 
-static void xgbe_i2c_isr_task(struct tasklet_struct *t)
+static void xgbe_i2c_isr_bh_work(struct work_struct *work)
 {
-       struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_i2c);
+       struct xgbe_prv_data *pdata = from_work(pdata, work, i2c_bh_work);
        struct xgbe_i2c_op_state *state = &pdata->i2c.op_state;
        unsigned int isr;
 
@@ -321,10 +321,10 @@ static irqreturn_t xgbe_i2c_isr(int irq, void *data)
 {
        struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
 
-       if (pdata->isr_as_tasklet)
-               tasklet_schedule(&pdata->tasklet_i2c);
+       if (pdata->isr_as_bh_work)
+               queue_work(system_bh_wq, &pdata->i2c_bh_work);
        else
-               xgbe_i2c_isr_task(&pdata->tasklet_i2c);
+               xgbe_i2c_isr_bh_work(&pdata->i2c_bh_work);
 
        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)
 {
-       xgbe_i2c_isr_task(&pdata->tasklet_i2c);
+       xgbe_i2c_isr_bh_work(&pdata->i2c_bh_work);
 
        return IRQ_HANDLED;
 }
@@ -449,7 +449,7 @@ static void xgbe_i2c_stop(struct xgbe_prv_data *pdata)
 
        if (pdata->dev_irq != pdata->i2c_irq) {
                devm_free_irq(pdata->dev, pdata->i2c_irq, pdata);
-               tasklet_kill(&pdata->tasklet_i2c);
+               cancel_work_sync(&pdata->i2c_bh_work);
        }
 }
 
@@ -464,7 +464,7 @@ static int xgbe_i2c_start(struct xgbe_prv_data *pdata)
 
        /* If we have a separate I2C irq, enable it */
        if (pdata->dev_irq != pdata->i2c_irq) {
-               tasklet_setup(&pdata->tasklet_i2c, xgbe_i2c_isr_task);
+               INIT_WORK(&pdata->i2c_bh_work, xgbe_i2c_isr_bh_work);
 
                ret = devm_request_irq(pdata->dev, pdata->i2c_irq,
                                       xgbe_i2c_isr, 0, pdata->i2c_name,

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
index 4a2dc70..07f4f34 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
@@ -703,9 +703,9 @@ static void xgbe_an73_isr(struct xgbe_prv_data *pdata)
        }
 }
 
-static void xgbe_an_isr_task(struct tasklet_struct *t)
+static void xgbe_an_isr_bh_work(struct work_struct *work)
 {
-       struct xgbe_prv_data *pdata = from_tasklet(pdata, t, tasklet_an);
+       struct xgbe_prv_data *pdata = from_work(pdata, work, an_bh_work);
 
        netif_dbg(pdata, intr, pdata->netdev, "AN interrupt received\n");
 
@@ -727,17 +727,17 @@ static irqreturn_t xgbe_an_isr(int irq, void *data)
 {
        struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
 
-       if (pdata->isr_as_tasklet)
-               tasklet_schedule(&pdata->tasklet_an);
+       if (pdata->isr_as_bh_work)
+               queue_work(system_bh_wq, &pdata->an_bh_work);
        else
-               xgbe_an_isr_task(&pdata->tasklet_an);
+               xgbe_an_isr_bh_work(&pdata->an_bh_work);
 
        return IRQ_HANDLED;
 }
 
 static irqreturn_t xgbe_an_combined_isr(struct xgbe_prv_data *pdata)
 {
-       xgbe_an_isr_task(&pdata->tasklet_an);
+       xgbe_an_isr_bh_work(&pdata->an_bh_work);
 
        return IRQ_HANDLED;
 }
@@ -1454,7 +1454,7 @@ static void xgbe_phy_stop(struct xgbe_prv_data *pdata)
 
        if (pdata->dev_irq != pdata->an_irq) {
                devm_free_irq(pdata->dev, pdata->an_irq, pdata);
-               tasklet_kill(&pdata->tasklet_an);
+               cancel_work_sync(&pdata->an_bh_work);
        }
 
        pdata->phy_if.phy_impl.stop(pdata);
@@ -1477,7 +1477,7 @@ static int xgbe_phy_start(struct xgbe_prv_data *pdata)
 
        /* If we have a separate AN irq, enable it */
        if (pdata->dev_irq != pdata->an_irq) {
-               tasklet_setup(&pdata->tasklet_an, xgbe_an_isr_task);
+               INIT_WORK(&pdata->an_bh_work, xgbe_an_isr_bh_work);
 
                ret = devm_request_irq(pdata->dev, pdata->an_irq,
                                       xgbe_an_isr, 0, pdata->an_name,

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
index c5e5fac..c636999 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
@@ -139,7 +139,7 @@ static int xgbe_config_multi_msi(struct xgbe_prv_data *pdata)
                return ret;
        }
 
-       pdata->isr_as_tasklet = 1;
+       pdata->isr_as_bh_work = 1;
        pdata->irq_count = ret;
 
        pdata->dev_irq = pci_irq_vector(pdata->pcidev, 0);
@@ -176,7 +176,7 @@ static int xgbe_config_irqs(struct xgbe_prv_data *pdata)
                return ret;
        }
 
-       pdata->isr_as_tasklet = pdata->pcidev->msi_enabled ? 1 : 0;
+       pdata->isr_as_bh_work = pdata->pcidev->msi_enabled ? 1 : 0;
        pdata->irq_count = 1;
        pdata->channel_irq_count = 1;
 

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe.h b/drivers/net/ethernet/amd/xgbe/xgbe.h
index f01a1e5..d85386c 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe.h
@@ -1298,11 +1298,11 @@ struct xgbe_prv_data {
 
        unsigned int lpm_ctrl;          /* CTRL1 for resume */
 
-       unsigned int isr_as_tasklet;
-       struct tasklet_struct tasklet_dev;
-       struct tasklet_struct tasklet_ecc;
-       struct tasklet_struct tasklet_i2c;
-       struct tasklet_struct tasklet_an;
+       unsigned int isr_as_bh_work;
+       struct work_struct dev_bh_work;
+       struct work_struct ecc_bh_work;
+       struct work_struct i2c_bh_work;
+       struct work_struct an_bh_work;
 
        struct dentry *xgbe_debugfs;