amd-xgbe: Re-issue interrupt if interrupt status not cleared

Some of the device interrupts should function as level interrupts. For
some hardware configurations this requires setting some control bits
so that if the interrupt status has not been cleared the interrupt
should be reissued.

Additionally, when using MSI or MSI-X interrupts, run the interrupt
service routine as a tasklet so that the re-issuance of the interrupt
is handled properly.

Signed-off-by: Tom Lendacky <thomas.lendacky@amd.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-common.h b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
index 127adbeefb105cc031f3782b534d175f29fb7143..e7b68043d6277b433fbe7141d4994023eae10523 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-common.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
@@ -959,6 +959,7 @@
 #define XP_DRIVER_INT_RO               0x0064
 #define XP_DRIVER_SCRATCH_0            0x0068
 #define XP_DRIVER_SCRATCH_1            0x006c
+#define XP_INT_REISSUE_EN              0x0074
 #define XP_INT_EN                      0x0078
 #define XP_I2C_MUTEX                   0x0080
 #define XP_MDIO_MUTEX                  0x0084

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
index 20685100ce12d3370d68c1572c896b18a7fea67c..ff6d20496526aea9119d1a95d00987f40cd554d0 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-drv.c
@@ -382,9 +382,9 @@ static bool xgbe_ecc_ded(struct xgbe_prv_data *pdata, unsigned long *period,
        return false;
 }
 
-static irqreturn_t xgbe_ecc_isr(int irq, void *data)
+static void xgbe_ecc_isr_task(unsigned long data)
 {
-       struct xgbe_prv_data *pdata = data;
+       struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
        unsigned int ecc_isr;
        bool stop = false;
 
@@ -435,12 +435,26 @@ out:
        /* Clear all ECC interrupts */
        XP_IOWRITE(pdata, XP_ECC_ISR, ecc_isr);
 
-       return IRQ_HANDLED;
+       /* Reissue interrupt if status is not clear */
+       if (pdata->vdata->irq_reissue_support)
+               XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 1);
 }
 
-static irqreturn_t xgbe_isr(int irq, void *data)
+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);
+       else
+               xgbe_ecc_isr_task((unsigned long)pdata);
+
+       return IRQ_HANDLED;
+}
+
+static void xgbe_isr_task(unsigned long data)
+{
+       struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
        struct xgbe_hw_if *hw_if = &pdata->hw_if;
        struct xgbe_channel *channel;
        unsigned int dma_isr, dma_ch_isr;
@@ -543,15 +557,36 @@ static irqreturn_t xgbe_isr(int irq, void *data)
 isr_done:
        /* If there is not a separate AN irq, handle it here */
        if (pdata->dev_irq == pdata->an_irq)
-               pdata->phy_if.an_isr(irq, pdata);
+               pdata->phy_if.an_isr(pdata);
 
        /* 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(irq, pdata);
+               xgbe_ecc_isr_task((unsigned long)pdata);
 
        /* If there is not a separate I2C irq, handle it here */
        if (pdata->vdata->i2c_support && (pdata->dev_irq == pdata->i2c_irq))
-               pdata->i2c_if.i2c_isr(irq, pdata);
+               pdata->i2c_if.i2c_isr(pdata);
+
+       /* Reissue interrupt if status is not clear */
+       if (pdata->vdata->irq_reissue_support) {
+               unsigned int reissue_mask;
+
+               reissue_mask = 1 << 0;
+               if (!pdata->per_channel_irq)
+                       reissue_mask |= 0xffff < 4;
+
+               XP_IOWRITE(pdata, XP_INT_REISSUE_EN, reissue_mask);
+       }
+}
+
+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);
+       else
+               xgbe_isr_task((unsigned long)pdata);
 
        return IRQ_HANDLED;
 }
@@ -826,6 +861,10 @@ static int xgbe_request_irqs(struct xgbe_prv_data *pdata)
        unsigned int i;
        int ret;
 
+       tasklet_init(&pdata->tasklet_dev, xgbe_isr_task, (unsigned long)pdata);
+       tasklet_init(&pdata->tasklet_ecc, xgbe_ecc_isr_task,
+                    (unsigned long)pdata);
+
        ret = devm_request_irq(pdata->dev, pdata->dev_irq, xgbe_isr, 0,
                               netdev->name, pdata);
        if (ret) {

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c b/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
index 417bdb5982a93ca252962f7fcd6141a2f53fca37..4d9062d35930f74bfd7864ff989d0dcf4c054325 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-i2c.c
@@ -274,13 +274,16 @@ static void xgbe_i2c_clear_isr_interrupts(struct xgbe_prv_data *pdata,
                XI2C_IOREAD(pdata, IC_CLR_STOP_DET);
 }
 
-static irqreturn_t xgbe_i2c_isr(int irq, void *data)
+static void xgbe_i2c_isr_task(unsigned long data)
 {
        struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
        struct xgbe_i2c_op_state *state = &pdata->i2c.op_state;
        unsigned int isr;
 
        isr = XI2C_IOREAD(pdata, IC_RAW_INTR_STAT);
+       if (!isr)
+               goto reissue_check;
+
        netif_dbg(pdata, intr, pdata->netdev,
                  "I2C interrupt received: status=%#010x\n", isr);
 
@@ -308,6 +311,21 @@ out:
        if (state->ret || XI2C_GET_BITS(isr, IC_RAW_INTR_STAT, STOP_DET))
                complete(&pdata->i2c_complete);
 
+reissue_check:
+       /* Reissue interrupt if status is not clear */
+       if (pdata->vdata->irq_reissue_support)
+               XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 2);
+}
+
+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);
+       else
+               xgbe_i2c_isr_task((unsigned long)pdata);
+
        return IRQ_HANDLED;
 }
 
@@ -349,12 +367,11 @@ static void xgbe_i2c_set_target(struct xgbe_prv_data *pdata, unsigned int addr)
        XI2C_IOWRITE(pdata, IC_TAR, addr);
 }
 
-static irqreturn_t xgbe_i2c_combined_isr(int irq, struct xgbe_prv_data *pdata)
+static irqreturn_t xgbe_i2c_combined_isr(struct xgbe_prv_data *pdata)
 {
-       if (!XI2C_IOREAD(pdata, IC_RAW_INTR_STAT))
-               return IRQ_HANDLED;
+       xgbe_i2c_isr_task((unsigned long)pdata);
 
-       return xgbe_i2c_isr(irq, pdata);
+       return IRQ_HANDLED;
 }
 
 static int xgbe_i2c_xfer(struct xgbe_prv_data *pdata, struct xgbe_i2c_op *op)
@@ -445,6 +462,9 @@ 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_init(&pdata->tasklet_i2c, xgbe_i2c_isr_task,
+                            (unsigned long)pdata);
+
                ret = devm_request_irq(pdata->dev, pdata->i2c_irq,
                                       xgbe_i2c_isr, 0, pdata->i2c_name,
                                       pdata);

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
index b672d92495397bb3132c90e25db17872c4589fa6..80684914dd8a7516e57743c30033c5e357395be8 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-mdio.c
@@ -665,6 +665,10 @@ static void xgbe_an37_isr(struct xgbe_prv_data *pdata)
        } else {
                /* Enable AN interrupts */
                xgbe_an37_enable_interrupts(pdata);
+
+               /* Reissue interrupt if status is not clear */
+               if (pdata->vdata->irq_reissue_support)
+                       XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
        }
 }
 
@@ -684,10 +688,14 @@ static void xgbe_an73_isr(struct xgbe_prv_data *pdata)
        } else {
                /* Enable AN interrupts */
                xgbe_an73_enable_interrupts(pdata);
+
+               /* Reissue interrupt if status is not clear */
+               if (pdata->vdata->irq_reissue_support)
+                       XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
        }
 }
 
-static irqreturn_t xgbe_an_isr(int irq, void *data)
+static void xgbe_an_isr_task(unsigned long data)
 {
        struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;
 
@@ -705,13 +713,25 @@ static irqreturn_t xgbe_an_isr(int irq, void *data)
        default:
                break;
        }
+}
+
+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);
+       else
+               xgbe_an_isr_task((unsigned long)pdata);
 
        return IRQ_HANDLED;
 }
 
-static irqreturn_t xgbe_an_combined_isr(int irq, struct xgbe_prv_data *pdata)
+static irqreturn_t xgbe_an_combined_isr(struct xgbe_prv_data *pdata)
 {
-       return xgbe_an_isr(irq, pdata);
+       xgbe_an_isr_task((unsigned long)pdata);
+
+       return IRQ_HANDLED;
 }
 
 static void xgbe_an_irq_work(struct work_struct *work)
@@ -915,6 +935,10 @@ static void xgbe_an_state_machine(struct work_struct *work)
                break;
        }
 
+       /* Reissue interrupt if status is not clear */
+       if (pdata->vdata->irq_reissue_support)
+               XP_IOWRITE(pdata, XP_INT_REISSUE_EN, 1 << 3);
+
        mutex_unlock(&pdata->an_mutex);
 }
 
@@ -1379,6 +1403,9 @@ 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_init(&pdata->tasklet_an, xgbe_an_isr_task,
+                            (unsigned long)pdata);
+
                ret = devm_request_irq(pdata->dev, pdata->an_irq,
                                       xgbe_an_isr, 0, pdata->an_name,
                                       pdata);

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
index 38392a5207258e707c7aac9f638fb592ad2bd890..f0c2e88a5037b6e80beae0365d4b7de33056d713 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-pci.c
@@ -139,6 +139,7 @@ static int xgbe_config_multi_msi(struct xgbe_prv_data *pdata)
                return ret;
        }
 
+       pdata->isr_as_tasklet = 1;
        pdata->irq_count = ret;
 
        pdata->dev_irq = pci_irq_vector(pdata->pcidev, 0);
@@ -175,6 +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->irq_count = 1;
        pdata->channel_irq_count = 1;
 
@@ -445,6 +447,7 @@ static const struct xgbe_version_data xgbe_v2a = {
        .tx_tstamp_workaround           = 1,
        .ecc_support                    = 1,
        .i2c_support                    = 1,
+       .irq_reissue_support            = 1,
 };
 
 static const struct xgbe_version_data xgbe_v2b = {
@@ -456,6 +459,7 @@ static const struct xgbe_version_data xgbe_v2b = {
        .tx_tstamp_workaround           = 1,
        .ecc_support                    = 1,
        .i2c_support                    = 1,
+       .irq_reissue_support            = 1,
 };
 
 static const struct pci_device_id xgbe_pci_table[] = {

diff --git a/drivers/net/ethernet/amd/xgbe/xgbe.h b/drivers/net/ethernet/amd/xgbe/xgbe.h
index f9a24639f5741bdc0d534cd7b155ad50acdb45c1..2834961a9c2562802dcc211d1e3d9d35c880b652 100644 (file)
--- a/drivers/net/ethernet/amd/xgbe/xgbe.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe.h
@@ -837,7 +837,7 @@ struct xgbe_phy_if {
        bool (*phy_valid_speed)(struct xgbe_prv_data *, int);
 
        /* For single interrupt support */
-       irqreturn_t (*an_isr)(int, struct xgbe_prv_data *);
+       irqreturn_t (*an_isr)(struct xgbe_prv_data *);
 
        /* PHY implementation specific services */
        struct xgbe_phy_impl_if phy_impl;
@@ -855,7 +855,7 @@ struct xgbe_i2c_if {
        int (*i2c_xfer)(struct xgbe_prv_data *, struct xgbe_i2c_op *);
 
        /* For single interrupt support */
-       irqreturn_t (*i2c_isr)(int, struct xgbe_prv_data *);
+       irqreturn_t (*i2c_isr)(struct xgbe_prv_data *);
 };
 
 struct xgbe_desc_if {
@@ -924,6 +924,7 @@ struct xgbe_version_data {
        unsigned int tx_tstamp_workaround;
        unsigned int ecc_support;
        unsigned int i2c_support;
+       unsigned int irq_reissue_support;
 };
 
 struct xgbe_prv_data {
@@ -1159,6 +1160,12 @@ 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;
+
 #ifdef CONFIG_DEBUG_FS
        struct dentry *xgbe_debugfs;