soundwire: qcom: add support to new interrupts

Add support to new interrupts which includes reporting some of the
error interrupts and adding support to SLAVE pending interrupt!

This patch also changes the interrupt handler behaviour on handling
any pending interrupts by checking it before returning out of irq handler.

Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Reviewed-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Link: https://lore.kernel.org/r/20210330144719.13284-7-srinivas.kandagatla@linaro.org
Signed-off-by: Vinod Koul <vkoul@kernel.org>

diff --git a/drivers/soundwire/qcom.c b/drivers/soundwire/qcom.c
index faa4c84dcf61bc5f6b588a406582b81048ef4638..1ad07784db4b46fbdca6178cd6a883ea0e58e997 100644 (file)
--- a/drivers/soundwire/qcom.c
+++ b/drivers/soundwire/qcom.c
@@ -28,10 +28,21 @@
 #define SWRM_COMP_PARAMS_DIN_PORTS_MASK                                GENMASK(9, 5)
 #define SWRM_INTERRUPT_STATUS                                  0x200
 #define SWRM_INTERRUPT_STATUS_RMSK                             GENMASK(16, 0)
+#define SWRM_INTERRUPT_STATUS_SLAVE_PEND_IRQ                   BIT(0)
 #define SWRM_INTERRUPT_STATUS_NEW_SLAVE_ATTACHED               BIT(1)
 #define SWRM_INTERRUPT_STATUS_CHANGE_ENUM_SLAVE_STATUS         BIT(2)
+#define SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET                 BIT(3)
+#define SWRM_INTERRUPT_STATUS_RD_FIFO_OVERFLOW                 BIT(4)
+#define SWRM_INTERRUPT_STATUS_RD_FIFO_UNDERFLOW                        BIT(5)
+#define SWRM_INTERRUPT_STATUS_WR_CMD_FIFO_OVERFLOW             BIT(6)
 #define SWRM_INTERRUPT_STATUS_CMD_ERROR                                BIT(7)
+#define SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION              BIT(8)
+#define SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH                BIT(9)
 #define SWRM_INTERRUPT_STATUS_SPECIAL_CMD_ID_FINISHED          BIT(10)
+#define SWRM_INTERRUPT_STATUS_BUS_RESET_FINISHED_V2             BIT(13)
+#define SWRM_INTERRUPT_STATUS_CLK_STOP_FINISHED_V2              BIT(14)
+#define SWRM_INTERRUPT_STATUS_EXT_CLK_STOP_WAKEUP               BIT(16)
+#define SWRM_INTERRUPT_MAX                                     17
 #define SWRM_INTERRUPT_MASK_ADDR                               0x204
 #define SWRM_INTERRUPT_CLEAR                                   0x208
 #define SWRM_INTERRUPT_CPU_EN                                  0x210
@@ -58,6 +69,7 @@
 #define SWRM_MCP_STATUS_BANK_NUM_MASK                          BIT(0)
 #define SWRM_MCP_SLV_STATUS                                    0x1090
 #define SWRM_MCP_SLV_STATUS_MASK                               GENMASK(1, 0)
+#define SWRM_MCP_SLV_STATUS_SZ                                 2
 #define SWRM_DP_PORT_CTRL_BANK(n, m)   (0x1124 + 0x100 * (n - 1) + 0x40 * m)
 #define SWRM_DP_PORT_CTRL_2_BANK(n, m) (0x1128 + 0x100 * (n - 1) + 0x40 * m)
 #define SWRM_DP_BLOCK_CTRL_1(n)                (0x112C + 0x100 * (n - 1))
@@ -123,6 +135,7 @@ struct qcom_swrm_ctrl {
        int rows_index;
        unsigned long dout_port_mask;
        unsigned long din_port_mask;
+       u32 intr_mask;
        u8 rcmd_id;
        u8 wcmd_id;
        struct qcom_swrm_port_config pconfig[QCOM_SDW_MAX_PORTS];
@@ -305,6 +318,25 @@ static int qcom_swrm_cmd_fifo_rd_cmd(struct qcom_swrm_ctrl *swrm,
        return SDW_CMD_IGNORED;
 }
 
+static int qcom_swrm_get_alert_slave_dev_num(struct qcom_swrm_ctrl *ctrl)
+{
+       u32 val, status;
+       int dev_num;
+
+       ctrl->reg_read(ctrl, SWRM_MCP_SLV_STATUS, &val);
+
+       for (dev_num = 0; dev_num < SDW_MAX_DEVICES; dev_num++) {
+               status = (val >> (dev_num * SWRM_MCP_SLV_STATUS_SZ));
+
+               if ((status & SWRM_MCP_SLV_STATUS_MASK) == SDW_SLAVE_ALERT) {
+                       ctrl->status[dev_num] = status;
+                       return dev_num;
+               }
+       }
+
+       return -EINVAL;
+}
+
 static void qcom_swrm_get_device_status(struct qcom_swrm_ctrl *ctrl)
 {
        u32 val;
@@ -323,36 +355,112 @@ static void qcom_swrm_get_device_status(struct qcom_swrm_ctrl *ctrl)
 
 static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id)
 {
-       struct qcom_swrm_ctrl *ctrl = dev_id;
-       u32 sts, value;
+       struct qcom_swrm_ctrl *swrm = dev_id;
+       u32 value, intr_sts, intr_sts_masked;
+       u32 i;
+       u8 devnum = 0;
+       int ret = IRQ_HANDLED;
 
-       ctrl->reg_read(ctrl, SWRM_INTERRUPT_STATUS, &sts);
+       swrm->reg_read(swrm, SWRM_INTERRUPT_STATUS, &intr_sts);
+       intr_sts_masked = intr_sts & swrm->intr_mask;
 
-       if (sts & SWRM_INTERRUPT_STATUS_CMD_ERROR) {
-               ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
-               dev_err_ratelimited(ctrl->dev,
-                                   "CMD error, fifo status 0x%x\n",
-                                    value);
-               ctrl->reg_write(ctrl, SWRM_CMD_FIFO_CMD, 0x1);
-       }
-
-       if ((sts & SWRM_INTERRUPT_STATUS_NEW_SLAVE_ATTACHED) ||
-           sts & SWRM_INTERRUPT_STATUS_CHANGE_ENUM_SLAVE_STATUS) {
-               qcom_swrm_get_device_status(ctrl);
-               sdw_handle_slave_status(&ctrl->bus, ctrl->status);
-       }
-
-       /**
-        * clear the interrupt before complete() is called, as complete can
-        * schedule new read/writes which require interrupts, clearing the
-        * interrupt would avoid missing interrupts in such cases.
-        */
-       ctrl->reg_write(ctrl, SWRM_INTERRUPT_CLEAR, sts);
+       do {
+               for (i = 0; i < SWRM_INTERRUPT_MAX; i++) {
+                       value = intr_sts_masked & BIT(i);
+                       if (!value)
+                               continue;
+
+                       switch (value) {
+                       case SWRM_INTERRUPT_STATUS_SLAVE_PEND_IRQ:
+                               devnum = qcom_swrm_get_alert_slave_dev_num(swrm);
+                               if (devnum < 0) {
+                                       dev_err_ratelimited(swrm->dev,
+                                           "no slave alert found.spurious interrupt\n");
+                               } else {
+                                       sdw_handle_slave_status(&swrm->bus, swrm->status);
+                               }
 
-       if (sts & SWRM_INTERRUPT_STATUS_SPECIAL_CMD_ID_FINISHED)
-               complete(&ctrl->broadcast);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_NEW_SLAVE_ATTACHED:
+                       case SWRM_INTERRUPT_STATUS_CHANGE_ENUM_SLAVE_STATUS:
+                               dev_err_ratelimited(swrm->dev, "%s: SWR new slave attached\n",
+                                       __func__);
+                               qcom_swrm_get_device_status(swrm);
+                               sdw_handle_slave_status(&swrm->bus, swrm->status);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET:
+                               dev_err_ratelimited(swrm->dev,
+                                               "%s: SWR bus clsh detected\n",
+                                               __func__);
+                               swrm->intr_mask &= ~SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET;
+                               swrm->reg_write(swrm, SWRM_INTERRUPT_CPU_EN, swrm->intr_mask);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_RD_FIFO_OVERFLOW:
+                               swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value);
+                               dev_err_ratelimited(swrm->dev,
+                                       "%s: SWR read FIFO overflow fifo status 0x%x\n",
+                                       __func__, value);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_RD_FIFO_UNDERFLOW:
+                               swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value);
+                               dev_err_ratelimited(swrm->dev,
+                                       "%s: SWR read FIFO underflow fifo status 0x%x\n",
+                                       __func__, value);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_WR_CMD_FIFO_OVERFLOW:
+                               swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value);
+                               dev_err(swrm->dev,
+                                       "%s: SWR write FIFO overflow fifo status %x\n",
+                                       __func__, value);
+                               swrm->reg_write(swrm, SWRM_CMD_FIFO_CMD, 0x1);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_CMD_ERROR:
+                               swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value);
+                               dev_err_ratelimited(swrm->dev,
+                                       "%s: SWR CMD error, fifo status 0x%x, flushing fifo\n",
+                                       __func__, value);
+                               swrm->reg_write(swrm, SWRM_CMD_FIFO_CMD, 0x1);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION:
+                               dev_err_ratelimited(swrm->dev,
+                                               "%s: SWR Port collision detected\n",
+                                               __func__);
+                               swrm->intr_mask &= ~SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION;
+                               swrm->reg_write(swrm,
+                                       SWRM_INTERRUPT_CPU_EN, swrm->intr_mask);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH:
+                               dev_err_ratelimited(swrm->dev,
+                                       "%s: SWR read enable valid mismatch\n",
+                                       __func__);
+                               swrm->intr_mask &=
+                                       ~SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH;
+                               swrm->reg_write(swrm,
+                                       SWRM_INTERRUPT_CPU_EN, swrm->intr_mask);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_SPECIAL_CMD_ID_FINISHED:
+                               complete(&swrm->broadcast);
+                               break;
+                       case SWRM_INTERRUPT_STATUS_BUS_RESET_FINISHED_V2:
+                               break;
+                       case SWRM_INTERRUPT_STATUS_CLK_STOP_FINISHED_V2:
+                               break;
+                       case SWRM_INTERRUPT_STATUS_EXT_CLK_STOP_WAKEUP:
+                               break;
+                       default:
+                               dev_err_ratelimited(swrm->dev,
+                                               "%s: SWR unknown interrupt value: %d\n",
+                                               __func__, value);
+                               ret = IRQ_NONE;
+                               break;
+                       }
+               }
+               swrm->reg_write(swrm, SWRM_INTERRUPT_CLEAR, intr_sts);
+               swrm->reg_read(swrm, SWRM_INTERRUPT_STATUS, &intr_sts);
+               intr_sts_masked = intr_sts & swrm->intr_mask;
+       } while (intr_sts_masked);
 
-       return IRQ_HANDLED;
+       return ret;
 }
 
 static int qcom_swrm_init(struct qcom_swrm_ctrl *ctrl)
@@ -368,6 +476,7 @@ static int qcom_swrm_init(struct qcom_swrm_ctrl *ctrl)
        /* Disable Auto enumeration */
        ctrl->reg_write(ctrl, SWRM_ENUMERATOR_CFG_ADDR, 0);
 
+       ctrl->intr_mask = SWRM_INTERRUPT_STATUS_RMSK;
        /* Mask soundwire interrupts */
        ctrl->reg_write(ctrl, SWRM_INTERRUPT_MASK_ADDR,
                        SWRM_INTERRUPT_STATUS_RMSK);