1 files changed, 45 insertions, 29 deletions

diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 6fe11f8c5f6c..78e54cb8dfbe 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -25,31 +25,35 @@
 #include "drmP.h"
 #include "drm_dp_helper.h"
 
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_connector.h"
 #include "nouveau_encoder.h"
 #include "nouveau_crtc.h"
 
+#include <subdev/gpio.h>
+#include <subdev/i2c.h>
+
 u8 *
 nouveau_dp_bios_data(struct drm_device *dev, struct dcb_output *dcb, u8 **entry)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         struct bit_entry d;
         u8 *table;
         int i;
 
         if (bit_table(dev, 'd', &d)) {
-                NV_ERROR(dev, "BIT 'd' table not found\n");
+                NV_ERROR(drm, "BIT 'd' table not found\n");
                 return NULL;
         }
 
         if (d.version != 1) {
-                NV_ERROR(dev, "BIT 'd' table version %d unknown\n", d.version);
+                NV_ERROR(drm, "BIT 'd' table version %d unknown\n", d.version);
                 return NULL;
         }
 
         table = ROMPTR(dev, d.data[0]);
         if (!table) {
-                NV_ERROR(dev, "displayport table pointer invalid\n");
+                NV_ERROR(drm, "displayport table pointer invalid\n");
                 return NULL;
         }
 
@@ -60,7 +64,7 @@ nouveau_dp_bios_data(struct drm_device *dev, struct dcb_output *dcb, u8 **entry)
         case 0x40:
                 break;
         default:
-                NV_ERROR(dev, "displayport table 0x%02x unknown\n", table[0]);
+                NV_ERROR(drm, "displayport table 0x%02x unknown\n", table[0]);
                 return NULL;
         }
 
@@ -70,7 +74,7 @@ nouveau_dp_bios_data(struct drm_device *dev, struct dcb_output *dcb, u8 **entry)
                         return table;
         }
 
-        NV_ERROR(dev, "displayport encoder table not found\n");
+        NV_ERROR(drm, "displayport encoder table not found\n");
         return NULL;
 }
 
@@ -92,9 +96,10 @@ struct dp_state {
 static void
 dp_set_link_config(struct drm_device *dev, struct dp_state *dp)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 sink[2];
 
-        NV_DEBUG_KMS(dev, "%d lanes at %d KB/s\n", dp->link_nr, dp->link_bw);
+        NV_DEBUG(drm, "%d lanes at %d KB/s\n", dp->link_nr, dp->link_bw);
 
         /* set desired link configuration on the source */
         dp->func->link_set(dev, dp->dcb, dp->crtc, dp->link_nr, dp->link_bw,
@@ -106,27 +111,29 @@ dp_set_link_config(struct drm_device *dev, struct dp_state *dp)
         if (dp->dpcd[2] & DP_ENHANCED_FRAME_CAP)
                 sink[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
 
-        auxch_wr(dev, dp->auxch, DP_LINK_BW_SET, sink, 2);
+        nv_wraux(dp->auxch, DP_LINK_BW_SET, sink, 2);
 }
 
 static void
 dp_set_training_pattern(struct drm_device *dev, struct dp_state *dp, u8 pattern)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 sink_tp;
 
-        NV_DEBUG_KMS(dev, "training pattern %d\n", pattern);
+        NV_DEBUG(drm, "training pattern %d\n", pattern);
 
         dp->func->train_set(dev, dp->dcb, pattern);
 
-        auxch_rd(dev, dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
+        nv_rdaux(dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
         sink_tp &= ~DP_TRAINING_PATTERN_MASK;
         sink_tp |= pattern;
-        auxch_wr(dev, dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
+        nv_wraux(dp->auxch, DP_TRAINING_PATTERN_SET, &sink_tp, 1);
 }
 
 static int
 dp_link_train_commit(struct drm_device *dev, struct dp_state *dp)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int i;
 
         for (i = 0; i < dp->link_nr; i++) {
@@ -140,25 +147,26 @@ dp_link_train_commit(struct drm_device *dev, struct dp_state *dp)
                 if ((lpre << 3) == DP_TRAIN_PRE_EMPHASIS_9_5)
                         dp->conf[i] |= DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
 
-                NV_DEBUG_KMS(dev, "config lane %d %02x\n", i, dp->conf[i]);
+                NV_DEBUG(drm, "config lane %d %02x\n", i, dp->conf[i]);
                 dp->func->train_adj(dev, dp->dcb, i, lvsw, lpre);
         }
 
-        return auxch_wr(dev, dp->auxch, DP_TRAINING_LANE0_SET, dp->conf, 4);
+        return nv_wraux(dp->auxch, DP_TRAINING_LANE0_SET, dp->conf, 4);
 }
 
 static int
 dp_link_train_update(struct drm_device *dev, struct dp_state *dp, u32 delay)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         int ret;
 
         udelay(delay);
 
-        ret = auxch_rd(dev, dp->auxch, DP_LANE0_1_STATUS, dp->stat, 6);
+        ret = nv_rdaux(dp->auxch, DP_LANE0_1_STATUS, dp->stat, 6);
         if (ret)
                 return ret;
 
-        NV_DEBUG_KMS(dev, "status %02x %02x %02x %02x %02x %02x\n",
+        NV_DEBUG(drm, "status %02x %02x %02x %02x %02x %02x\n",
                      dp->stat[0], dp->stat[1], dp->stat[2], dp->stat[3],
                      dp->stat[4], dp->stat[5]);
         return 0;
@@ -287,11 +295,14 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
         struct nouveau_connector *nv_connector =
                 nouveau_encoder_connector_get(nv_encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
+        struct nouveau_gpio *gpio = nouveau_gpio(drm->device);
         const u32 bw_list[] = { 270000, 162000, 0 };
         const u32 *link_bw = bw_list;
         struct dp_state dp;
 
-        dp.auxch = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
+        dp.auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
         if (!dp.auxch)
                 return false;
 
@@ -307,7 +318,7 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
          * we take during link training (DP_SET_POWER is one), we need
          * to ignore them for the moment to avoid races.
          */
-        nouveau_gpio_irq(dev, 0, nv_connector->hpd, 0xff, false);
+        gpio->irq(gpio, 0, nv_connector->hpd, 0xff, false);
 
         /* enable down-spreading, if possible */
         dp_set_downspread(dev, &dp, nv_encoder->dp.dpcd[3] & 1);
@@ -350,7 +361,7 @@ nouveau_dp_link_train(struct drm_encoder *encoder, u32 datarate,
         dp_link_train_fini(dev, &dp);
 
         /* re-enable hotplug detect */
-        nouveau_gpio_irq(dev, 0, nv_connector->hpd, 0xff, true);
+        gpio->irq(gpio, 0, nv_connector->hpd, 0xff, true);
         return true;
 }
 
@@ -359,10 +370,12 @@ nouveau_dp_dpms(struct drm_encoder *encoder, int mode, u32 datarate,
                 struct dp_train_func *func)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+        struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
         struct nouveau_i2c_port *auxch;
         u8 status;
 
-        auxch = nouveau_i2c_find(encoder->dev, nv_encoder->dcb->i2c_index);
+        auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
         if (!auxch)
                 return;
 
@@ -371,7 +384,7 @@ nouveau_dp_dpms(struct drm_encoder *encoder, int mode, u32 datarate,
         else
                 status = DP_SET_POWER_D3;
 
-        auxch_wr(encoder->dev, auxch, DP_SET_POWER, &status, 1);
+        nv_wraux(auxch, DP_SET_POWER, &status, 1);
 
         if (mode == DRM_MODE_DPMS_ON)
                 nouveau_dp_link_train(encoder, datarate, func);
@@ -381,17 +394,18 @@ static void
 nouveau_dp_probe_oui(struct drm_device *dev, struct nouveau_i2c_port *auxch,
                      u8 *dpcd)
 {
+        struct nouveau_drm *drm = nouveau_drm(dev);
         u8 buf[3];
 
         if (!(dpcd[DP_DOWN_STREAM_PORT_COUNT] & DP_OUI_SUPPORT))
                 return;
 
-        if (!auxch_rd(dev, auxch, DP_SINK_OUI, buf, 3))
-                NV_DEBUG_KMS(dev, "Sink OUI: %02hx%02hx%02hx\n",
+        if (!nv_rdaux(auxch, DP_SINK_OUI, buf, 3))
+                NV_DEBUG(drm, "Sink OUI: %02hx%02hx%02hx\n",
                              buf[0], buf[1], buf[2]);
 
-        if (!auxch_rd(dev, auxch, DP_BRANCH_OUI, buf, 3))
-                NV_DEBUG_KMS(dev, "Branch OUI: %02hx%02hx%02hx\n",
+        if (!nv_rdaux(auxch, DP_BRANCH_OUI, buf, 3))
+                NV_DEBUG(drm, "Branch OUI: %02hx%02hx%02hx\n",
                              buf[0], buf[1], buf[2]);
 
 }
@@ -401,24 +415,26 @@ nouveau_dp_detect(struct drm_encoder *encoder)
 {
         struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
         struct drm_device *dev = encoder->dev;
+        struct nouveau_drm *drm = nouveau_drm(dev);
+        struct nouveau_i2c *i2c = nouveau_i2c(drm->device);
         struct nouveau_i2c_port *auxch;
         u8 *dpcd = nv_encoder->dp.dpcd;
         int ret;
 
-        auxch = nouveau_i2c_find(dev, nv_encoder->dcb->i2c_index);
+        auxch = i2c->find(i2c, nv_encoder->dcb->i2c_index);
         if (!auxch)
                 return false;
 
-        ret = auxch_rd(dev, auxch, DP_DPCD_REV, dpcd, 8);
+        ret = nv_rdaux(auxch, DP_DPCD_REV, dpcd, 8);
         if (ret)
                 return false;
 
         nv_encoder->dp.link_bw = 27000 * dpcd[1];
         nv_encoder->dp.link_nr = dpcd[2] & DP_MAX_LANE_COUNT_MASK;
 
-        NV_DEBUG_KMS(dev, "display: %dx%d dpcd 0x%02x\n",
+        NV_DEBUG(drm, "display: %dx%d dpcd 0x%02x\n",
                      nv_encoder->dp.link_nr, nv_encoder->dp.link_bw, dpcd[0]);
-        NV_DEBUG_KMS(dev, "encoder: %dx%d\n",
+        NV_DEBUG(drm, "encoder: %dx%d\n",
                      nv_encoder->dcb->dpconf.link_nr,
                      nv_encoder->dcb->dpconf.link_bw);
 
@@ -427,7 +443,7 @@ nouveau_dp_detect(struct drm_encoder *encoder)
         if (nv_encoder->dcb->dpconf.link_bw < nv_encoder->dp.link_bw)
                 nv_encoder->dp.link_bw = nv_encoder->dcb->dpconf.link_bw;
 
-        NV_DEBUG_KMS(dev, "maximum: %dx%d\n",
+        NV_DEBUG(drm, "maximum: %dx%d\n",
                      nv_encoder->dp.link_nr, nv_encoder->dp.link_bw);
 
         nouveau_dp_probe_oui(dev, auxch, dpcd);