1 files changed, 105 insertions, 9 deletions

diff --git a/drivers/gpu/drm/i2c/tda998x_drv.c b/drivers/gpu/drm/i2c/tda998x_drv.c
index fddac4c84c28..c9882246d81f 100644
--- a/drivers/gpu/drm/i2c/tda998x_drv.c
+++ b/drivers/gpu/drm/i2c/tda998x_drv.c
@@ -19,6 +19,7 @@
 
 #include <linux/hdmi.h>
 #include <linux/module.h>
+#include <linux/irq.h>
 #include <sound/asoundef.h>
 
 #include <drm/drmP.h>
@@ -40,6 +41,10 @@ struct tda998x_priv {
         u8 vip_cntrl_1;
         u8 vip_cntrl_2;
         struct tda998x_encoder_params params;
+
+        wait_queue_head_t wq_edid;
+        volatile int wq_edid_wait;
+        struct drm_encoder *encoder;
 };
 
 #define to_tda998x_priv(x)  ((struct tda998x_priv *)to_encoder_slave(x)->slave_priv)
@@ -306,11 +311,16 @@ struct tda998x_priv {
 
 /* CEC registers: (not paged)
  */
+#define REG_CEC_INTSTATUS         0xee                /* read */
+# define CEC_INTSTATUS_CEC        (1 << 0)
+# define CEC_INTSTATUS_HDMI       (1 << 1)
 #define REG_CEC_FRO_IM_CLK_CTRL   0xfb                /* read/write */
 # define CEC_FRO_IM_CLK_CTRL_GHOST_DIS (1 << 7)
 # define CEC_FRO_IM_CLK_CTRL_ENA_OTP   (1 << 6)
 # define CEC_FRO_IM_CLK_CTRL_IMCLK_SEL (1 << 1)
 # define CEC_FRO_IM_CLK_CTRL_FRO_DIV   (1 << 0)
+#define REG_CEC_RXSHPDINTENA      0xfc                /* read/write */
+#define REG_CEC_RXSHPDINT         0xfd                /* read */
 #define REG_CEC_RXSHPDLEV         0xfe                /* read */
 # define CEC_RXSHPDLEV_RXSENS     (1 << 0)
 # define CEC_RXSHPDLEV_HPD        (1 << 1)
@@ -524,6 +534,35 @@ tda998x_reset(struct tda998x_priv *priv)
         reg_write(priv, REG_MUX_VP_VIP_OUT, 0x24);
 }
 
+/*
+ * only 2 interrupts may occur: screen plug/unplug and EDID read
+ */
+static irqreturn_t tda998x_irq_thread(int irq, void *data)
+{
+        struct tda998x_priv *priv = data;
+        u8 sta, cec, lvl, flag0, flag1, flag2;
+
+        if (!priv)
+                return IRQ_HANDLED;
+        sta = cec_read(priv, REG_CEC_INTSTATUS);
+        cec = cec_read(priv, REG_CEC_RXSHPDINT);
+        lvl = cec_read(priv, REG_CEC_RXSHPDLEV);
+        flag0 = reg_read(priv, REG_INT_FLAGS_0);
+        flag1 = reg_read(priv, REG_INT_FLAGS_1);
+        flag2 = reg_read(priv, REG_INT_FLAGS_2);
+        DRM_DEBUG_DRIVER(
+                "tda irq sta %02x cec %02x lvl %02x f0 %02x f1 %02x f2 %02x\n",
+                sta, cec, lvl, flag0, flag1, flag2);
+        if ((flag2 & INT_FLAGS_2_EDID_BLK_RD) && priv->wq_edid_wait) {
+                priv->wq_edid_wait = 0;
+                wake_up(&priv->wq_edid);
+        } else if (cec != 0) {                  /* HPD change */
+                if (priv->encoder && priv->encoder->dev)
+                        drm_helper_hpd_irq_event(priv->encoder->dev);
+        }
+        return IRQ_HANDLED;
+}
+
 static uint8_t tda998x_cksum(uint8_t *buf, size_t bytes)
 {
         uint8_t sum = 0;
@@ -994,23 +1033,36 @@ read_edid_block(struct drm_encoder *encoder, uint8_t *buf, int blk)
         reg_write(priv, REG_DDC_SEGM, segptr);
 
         /* enable reading EDID: */
+        priv->wq_edid_wait = 1;
         reg_write(priv, REG_EDID_CTRL, 0x1);
 
         /* flag must be cleared by sw: */
         reg_write(priv, REG_EDID_CTRL, 0x0);
 
         /* wait for block read to complete: */
-        for (i = 100; i > 0; i--) {
-                ret = reg_read(priv, REG_INT_FLAGS_2);
-                if (ret < 0)
-                        return ret;
-                if (ret & INT_FLAGS_2_EDID_BLK_RD)
-                        break;
-                msleep(1);
+        if (priv->hdmi->irq) {
+                i = wait_event_timeout(priv->wq_edid,
+                                        !priv->wq_edid_wait,
+                                        msecs_to_jiffies(100));
+                if (i < 0) {
+                        dev_err(encoder->dev->dev, "read edid wait err %d\n", i);
+                        return i;
+                }
+        } else {
+                for (i = 10; i > 0; i--) {
+                        msleep(10);
+                        ret = reg_read(priv, REG_INT_FLAGS_2);
+                        if (ret < 0)
+                                return ret;
+                        if (ret & INT_FLAGS_2_EDID_BLK_RD)
+                                break;
+                }
         }
 
-        if (i == 0)
+        if (i == 0) {
+                dev_err(encoder->dev->dev, "read edid timeout\n");
                 return -ETIMEDOUT;
+        }
 
         ret = reg_read_range(priv, REG_EDID_DATA_0, buf, EDID_LENGTH);
         if (ret != EDID_LENGTH) {
@@ -1108,7 +1160,13 @@ static int
 tda998x_encoder_create_resources(struct drm_encoder *encoder,
                                 struct drm_connector *connector)
 {
-        DBG("");
+        struct tda998x_priv *priv = to_tda998x_priv(encoder);
+
+        if (priv->hdmi->irq)
+                connector->polled = DRM_CONNECTOR_POLL_HPD;
+        else
+                connector->polled = DRM_CONNECTOR_POLL_CONNECT |
+                        DRM_CONNECTOR_POLL_DISCONNECT;
         return 0;
 }
 
@@ -1127,6 +1185,13 @@ tda998x_encoder_destroy(struct drm_encoder *encoder)
 {
         struct tda998x_priv *priv = to_tda998x_priv(encoder);
         drm_i2c_encoder_destroy(encoder);
+
+        /* disable all IRQs and free the IRQ handler */
+        cec_write(priv, REG_CEC_RXSHPDINTENA, 0);
+        reg_clear(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD);
+        if (priv->hdmi->irq)
+                free_irq(priv->hdmi->irq, priv);
+
         if (priv->cec)
                 i2c_unregister_device(priv->cec);
         kfree(priv);
@@ -1186,6 +1251,8 @@ tda998x_encoder_init(struct i2c_client *client,
                 kfree(priv);
                 return -ENODEV;
         }
+
+        priv->encoder = &encoder_slave->base;
         priv->dpms = DRM_MODE_DPMS_OFF;
 
         encoder_slave->slave_priv = priv;
@@ -1242,6 +1309,35 @@ tda998x_encoder_init(struct i2c_client *client,
         cec_write(priv, REG_CEC_FRO_IM_CLK_CTRL,
                         CEC_FRO_IM_CLK_CTRL_GHOST_DIS | CEC_FRO_IM_CLK_CTRL_IMCLK_SEL);
 
+        /* initialize the optional IRQ */
+        if (client->irq) {
+                int irqf_trigger;
+
+                /* init read EDID waitqueue */
+                init_waitqueue_head(&priv->wq_edid);
+
+                /* clear pending interrupts */
+                reg_read(priv, REG_INT_FLAGS_0);
+                reg_read(priv, REG_INT_FLAGS_1);
+                reg_read(priv, REG_INT_FLAGS_2);
+
+                irqf_trigger =
+                        irqd_get_trigger_type(irq_get_irq_data(client->irq));
+                ret = request_threaded_irq(client->irq, NULL,
+                                           tda998x_irq_thread,
+                                           irqf_trigger | IRQF_ONESHOT,
+                                           "tda998x", priv);
+                if (ret) {
+                        dev_err(&client->dev,
+                                "failed to request IRQ#%u: %d\n",
+                                client->irq, ret);
+                        goto fail;
+                }
+
+                /* enable HPD irq */
+                cec_write(priv, REG_CEC_RXSHPDINTENA, CEC_RXSHPDLEV_HPD);
+        }
+
         /* enable EDID read irq: */
         reg_set(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD);