drm/nouveau/disp: add method to control DPAUX pad power

This removes the need for NVKM to track DP HPD events, as the KMS
driver follows them already, and has better information available.

Signed-off-by: Ben Skeggs <bskeggs@redhat.com>
Reviewed-by: Lyude Paul <lyude@redhat.com>

diff --git a/drivers/gpu/drm/nouveau/include/nvif/if0012.h b/drivers/gpu/drm/nouveau/include/nvif/if0012.h
index c67f03d52d8cbb12863cc6323aa3c27981f8d3e1..d1583271f5d4dec466c8007ac6bdc226f1314b92 100644 (file)
--- a/drivers/gpu/drm/nouveau/include/nvif/if0012.h
+++ b/drivers/gpu/drm/nouveau/include/nvif/if0012.h
@@ -15,6 +15,7 @@ union nvif_outp_args {
 #define NVIF_OUTP_V0_RELEASE     0x02
 #define NVIF_OUTP_V0_INFOFRAME   0x03
 #define NVIF_OUTP_V0_HDA_ELD     0x04
+#define NVIF_OUTP_V0_DP_AUX_PWR  0x05
 
 union nvif_outp_load_detect_args {
        struct nvif_outp_load_detect_v0 {
@@ -91,4 +92,12 @@ union nvif_outp_hda_eld_args {
                __u8  data[];
        } v0;
 };
+
+union nvif_outp_dp_aux_pwr_args {
+       struct nvif_outp_dp_aux_pwr_v0 {
+               __u8 version;
+               __u8 state;
+               __u8 pad02[6];
+       } v0;
+};
 #endif

diff --git a/drivers/gpu/drm/nouveau/include/nvif/outp.h b/drivers/gpu/drm/nouveau/include/nvif/outp.h
index 88fd2b9703041a2a61d3c9164e040963e00347c8..1c960f6fdd7a120a1d3c7f48afa080e22d3d6d09 100644 (file)
--- a/drivers/gpu/drm/nouveau/include/nvif/outp.h
+++ b/drivers/gpu/drm/nouveau/include/nvif/outp.h
@@ -26,4 +26,5 @@ int nvif_outp_acquire_dp(struct nvif_outp *, u8 dpcd[16],
 void nvif_outp_release(struct nvif_outp *);
 int nvif_outp_infoframe(struct nvif_outp *, u8 type, struct nvif_outp_infoframe_v0 *, u32 size);
 int nvif_outp_hda_eld(struct nvif_outp *, int head, void *data, u32 size);
+int nvif_outp_dp_aux_pwr(struct nvif_outp *, bool enable);
 #endif

diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 20db8ea1a0baf377a3b0643f3c3973a4e21006b5..b7104e676eb292c09709653ca9af3e69e202f37e 100644 (file)
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -140,12 +140,17 @@ nouveau_dp_detect(struct nouveau_connector *nv_connector,
         * TODO: look into checking this before probing I2C to detect DVI/HDMI
         */
        hpd = nvif_conn_hpd_status(&nv_connector->conn);
-       if (hpd == NVIF_CONN_HPD_STATUS_NOT_PRESENT)
+       if (hpd == NVIF_CONN_HPD_STATUS_NOT_PRESENT) {
+               nvif_outp_dp_aux_pwr(&nv_encoder->outp, false);
                goto out;
+       }
+       nvif_outp_dp_aux_pwr(&nv_encoder->outp, true);
 
        status = nouveau_dp_probe_dpcd(nv_connector, nv_encoder);
-       if (status == connector_status_disconnected)
+       if (status == connector_status_disconnected) {
+               nvif_outp_dp_aux_pwr(&nv_encoder->outp, false);
                goto out;
+       }
 
        /* If we're in MST mode, we're done here */
        if (mstm && mstm->can_mst && mstm->is_mst) {
@@ -193,6 +198,7 @@ nouveau_dp_detect(struct nouveau_connector *nv_connector,
                        ret = NOUVEAU_DP_MST;
                        goto out;
                } else if (ret != 0) {
+                       nvif_outp_dp_aux_pwr(&nv_encoder->outp, false);
                        goto out;
                }
        }

diff --git a/drivers/gpu/drm/nouveau/nvif/outp.c b/drivers/gpu/drm/nouveau/nvif/outp.c
index 1ae5b19a8025cf4844a3268704cacc28d62ff1d1..9bd9cc21a03960f47051f53452777f02e52eb07c 100644 (file)
--- a/drivers/gpu/drm/nouveau/nvif/outp.c
+++ b/drivers/gpu/drm/nouveau/nvif/outp.c
@@ -25,6 +25,20 @@
 
 #include <nvif/class.h>
 
+int
+nvif_outp_dp_aux_pwr(struct nvif_outp *outp, bool enable)
+{
+       struct nvif_outp_dp_aux_pwr_v0 args;
+       int ret;
+
+       args.version = 0;
+       args.state = enable;
+
+       ret = nvif_object_mthd(&outp->object, NVIF_OUTP_V0_DP_AUX_PWR, &args, sizeof(args));
+       NVIF_ERRON(ret, &outp->object, "[DP_AUX_PWR state:%d]", args.state);
+       return ret;
+}
+
 int
 nvif_outp_hda_eld(struct nvif_outp *outp, int head, void *data, u32 size)
 {

diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.c b/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.c
index f1887b58f472d5ca14fab7e2ab9bc8b0debd41b1..92c9faecffae896481954419d2956443e156729a 100644 (file)
--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.c
@@ -612,18 +612,38 @@ nvkm_dp_enable_supported_link_rates(struct nvkm_outp *outp)
        return outp->dp.rates != 0;
 }
 
-static bool
-nvkm_dp_enable(struct nvkm_outp *outp, bool enable)
+void
+nvkm_dp_enable(struct nvkm_outp *outp, bool auxpwr)
 {
+       struct nvkm_gpio *gpio = outp->disp->engine.subdev.device->gpio;
        struct nvkm_i2c_aux *aux = outp->dp.aux;
 
-       if (enable) {
-               if (!outp->dp.present) {
-                       OUTP_DBG(outp, "aux power -> always");
-                       nvkm_i2c_aux_monitor(aux, true);
-                       outp->dp.present = true;
+       if (auxpwr && !outp->dp.aux_pwr) {
+               /* eDP panels need powering on by us (if the VBIOS doesn't default it
+                * to on) before doing any AUX channel transactions.  LVDS panel power
+                * is handled by the SOR itself, and not required for LVDS DDC.
+                */
+               if (outp->conn->info.type == DCB_CONNECTOR_eDP) {
+                       int power = nvkm_gpio_get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff);
+                       if (power == 0) {
+                               nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
+                               outp->dp.aux_pwr_pu = true;
+                       }
+
+                       /* We delay here unconditionally, even if already powered,
+                        * because some laptop panels having a significant resume
+                        * delay before the panel begins responding.
+                        *
+                        * This is likely a bit of a hack, but no better idea for
+                        * handling this at the moment.
+                        */
+                       msleep(300);
                }
 
+               OUTP_DBG(outp, "aux power -> always");
+               nvkm_i2c_aux_monitor(aux, true);
+               outp->dp.aux_pwr = true;
+
                /* Detect any LTTPRs before reading DPCD receiver caps. */
                if (!nvkm_rdaux(aux, DPCD_LTTPR_REV, outp->dp.lttpr, sizeof(outp->dp.lttpr)) &&
                    outp->dp.lttpr[0] >= 0x14 && outp->dp.lttpr[2]) {
@@ -676,19 +696,24 @@ nvkm_dp_enable(struct nvkm_outp *outp, bool enable)
                                        outp->dp.rates++;
                                }
                        }
-
-                       return true;
                }
-       }
-
-       if (outp->dp.present) {
+       } else
+       if (!auxpwr && outp->dp.aux_pwr) {
                OUTP_DBG(outp, "aux power -> demand");
                nvkm_i2c_aux_monitor(aux, false);
-               outp->dp.present = false;
-       }
+               outp->dp.aux_pwr = false;
+               atomic_set(&outp->dp.lt.done, 0);
 
-       atomic_set(&outp->dp.lt.done, 0);
-       return false;
+               /* Restore eDP panel GPIO to its prior state if we changed it, as
+                * it could potentially interfere with other outputs.
+                */
+               if (outp->conn->info.type == DCB_CONNECTOR_eDP) {
+                       if (outp->dp.aux_pwr_pu) {
+                               nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 0);
+                               outp->dp.aux_pwr_pu = false;
+                       }
+               }
+       }
 }
 
 static int
@@ -705,8 +730,6 @@ nvkm_dp_hpd(struct nvkm_notify *notify)
                if (atomic_read(&outp->dp.lt.done))
                        outp->func->acquire(outp);
                rep.mask |= NVIF_NOTIFY_CONN_V0_IRQ;
-       } else {
-               nvkm_dp_enable(outp, true);
        }
 
        if (line->mask & NVKM_I2C_UNPLUG)
@@ -728,37 +751,8 @@ nvkm_dp_fini(struct nvkm_outp *outp)
 static void
 nvkm_dp_init(struct nvkm_outp *outp)
 {
-       struct nvkm_gpio *gpio = outp->disp->engine.subdev.device->gpio;
-
+       nvkm_dp_enable(outp, outp->dp.enabled);
        nvkm_notify_put(&outp->conn->hpd);
-
-       /* eDP panels need powering on by us (if the VBIOS doesn't default it
-        * to on) before doing any AUX channel transactions.  LVDS panel power
-        * is handled by the SOR itself, and not required for LVDS DDC.
-        */
-       if (outp->conn->info.type == DCB_CONNECTOR_eDP) {
-               int power = nvkm_gpio_get(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff);
-               if (power == 0)
-                       nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 1);
-
-               /* We delay here unconditionally, even if already powered,
-                * because some laptop panels having a significant resume
-                * delay before the panel begins responding.
-                *
-                * This is likely a bit of a hack, but no better idea for
-                * handling this at the moment.
-                */
-               msleep(300);
-
-               /* If the eDP panel can't be detected, we need to restore
-                * the panel power GPIO to avoid breaking another output.
-                */
-               if (!nvkm_dp_enable(outp, true) && power == 0)
-                       nvkm_gpio_set(gpio, 0, DCB_GPIO_PANEL_POWER, 0xff, 0);
-       } else {
-               nvkm_dp_enable(outp, true);
-       }
-
        nvkm_notify_get(&outp->dp.hpd);
 }
 

diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.h b/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.h
index 1d86baa6a424a80d739564eaa363efe7ddaf2c80..9a6be43916bcc3e94e18cc32dd0318f7a3926da0 100644 (file)
--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.h
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/dp.h
@@ -6,6 +6,7 @@
 int nvkm_dp_new(struct nvkm_disp *, int index, struct dcb_output *,
                struct nvkm_outp **);
 void nvkm_dp_disable(struct nvkm_outp *, struct nvkm_ior *);
+void nvkm_dp_enable(struct nvkm_outp *, bool auxpwr);
 
 /* DPCD Receiver Capabilities */
 #define DPCD_RC00_DPCD_REV                                              0x00000

diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/outp.h b/drivers/gpu/drm/nouveau/nvkm/engine/disp/outp.h
index d7c989e1cd01b770d68ba733c5c8f441dcdab876..66def8ae316556234bd50b48eae4c63184b53868 100644 (file)
--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/outp.h
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/outp.h
@@ -39,7 +39,9 @@ struct nvkm_outp {
                        struct nvkm_i2c_aux *aux;
 
                        struct nvkm_notify hpd;
-                       bool present;
+                       bool enabled;
+                       bool aux_pwr;
+                       bool aux_pwr_pu;
                        u8 lttpr[6];
                        u8 lttprs;
                        u8 dpcd[16];

diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/uoutp.c b/drivers/gpu/drm/nouveau/nvkm/engine/disp/uoutp.c
index 61d41b326f43cea1d1a694bffe6a1e5ebb2dc977..3bfc3e39778e2e43a0592553cfa70c898035343f 100644 (file)
--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/uoutp.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/uoutp.c
@@ -21,11 +21,25 @@
  */
 #define nvkm_uoutp(p) container_of((p), struct nvkm_outp, object)
 #include "outp.h"
+#include "dp.h"
 #include "head.h"
 #include "ior.h"
 
 #include <nvif/if0012.h>
 
+static int
+nvkm_uoutp_mthd_dp_aux_pwr(struct nvkm_outp *outp, void *argv, u32 argc)
+{
+       union nvif_outp_dp_aux_pwr_args *args = argv;
+
+       if (argc != sizeof(args->v0) || args->v0.version != 0)
+               return -ENOSYS;
+
+       outp->dp.enabled = !!args->v0.state;
+       nvkm_dp_enable(outp, outp->dp.enabled);
+       return 0;
+}
+
 static int
 nvkm_uoutp_mthd_hda_eld(struct nvkm_outp *outp, void *argv, u32 argc)
 {
@@ -250,6 +264,7 @@ nvkm_uoutp_mthd_noacquire(struct nvkm_outp *outp, u32 mthd, void *argv, u32 argc
        switch (mthd) {
        case NVIF_OUTP_V0_LOAD_DETECT: return nvkm_uoutp_mthd_load_detect(outp, argv, argc);
        case NVIF_OUTP_V0_ACQUIRE    : return nvkm_uoutp_mthd_acquire    (outp, argv, argc);
+       case NVIF_OUTP_V0_DP_AUX_PWR : return nvkm_uoutp_mthd_dp_aux_pwr (outp, argv, argc);
        default:
                break;
        }