Merge branch 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...

[~andy/linux] / drivers / gpu / drm / nouveau / nv50_dac.c

diff --git a/drivers/gpu/drm/nouveau/nv50_dac.c b/drivers/gpu/drm/nouveau/nv50_dac.c
index 2bff2e588d87800dfd1db5905ce20892ca054b1c..6a30a1748573dca4a33882aa1a969e71082752f8 100644 (file)
--- a/drivers/gpu/drm/nouveau/nv50_dac.c
+++ b/drivers/gpu/drm/nouveau/nv50_dac.c
@@ -29,18 +29,21 @@
 
 #define NOUVEAU_DMA_DEBUG (nouveau_reg_debug & NOUVEAU_REG_DEBUG_EVO)
 #include "nouveau_reg.h"
-#include "nouveau_drv.h"
+#include "nouveau_drm.h"
 #include "nouveau_dma.h"
 #include "nouveau_encoder.h"
 #include "nouveau_connector.h"
 #include "nouveau_crtc.h"
 #include "nv50_display.h"
 
+#include <subdev/timer.h>
+
 static void
 nv50_dac_disconnect(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_channel *evo = nv50_display(dev)->master;
        int ret;
 
@@ -48,11 +51,11 @@ nv50_dac_disconnect(struct drm_encoder *encoder)
                return;
        nv50_crtc_blank(nouveau_crtc(nv_encoder->crtc), true);
 
-       NV_DEBUG_KMS(dev, "Disconnecting DAC %d\n", nv_encoder->or);
+       NV_DEBUG(drm, "Disconnecting DAC %d\n", nv_encoder->or);
 
        ret = RING_SPACE(evo, 4);
        if (ret) {
-               NV_ERROR(dev, "no space while disconnecting DAC\n");
+               NV_ERROR(drm, "no space while disconnecting DAC\n");
                return;
        }
        BEGIN_NV04(evo, 0, NV50_EVO_DAC(nv_encoder->or, MODE_CTRL), 1);
@@ -67,43 +70,43 @@ static enum drm_connector_status
 nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 {
        struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
-       struct drm_device *dev = encoder->dev;
-       struct drm_nouveau_private *dev_priv = dev->dev_private;
+       struct nouveau_device *device = nouveau_dev(encoder->dev);
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
        enum drm_connector_status status = connector_status_disconnected;
        uint32_t dpms_state, load_pattern, load_state;
        int or = nv_encoder->or;
 
-       nv_wr32(dev, NV50_PDISPLAY_DAC_CLK_CTRL1(or), 0x00000001);
-       dpms_state = nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or));
+       nv_wr32(device, NV50_PDISPLAY_DAC_CLK_CTRL1(or), 0x00000001);
+       dpms_state = nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or));
 
-       nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+       nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                0x00150000 | NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
-       if (!nv_wait(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+       if (!nv_wait(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                     NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING, 0)) {
-               NV_ERROR(dev, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
-               NV_ERROR(dev, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
-                         nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
+               NV_ERROR(drm, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
+               NV_ERROR(drm, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
+                         nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
                return status;
        }
 
        /* Use bios provided value if possible. */
-       if (dev_priv->vbios.dactestval) {
-               load_pattern = dev_priv->vbios.dactestval;
-               NV_DEBUG_KMS(dev, "Using bios provided load_pattern of %d\n",
+       if (drm->vbios.dactestval) {
+               load_pattern = drm->vbios.dactestval;
+               NV_DEBUG(drm, "Using bios provided load_pattern of %d\n",
                          load_pattern);
        } else {
                load_pattern = 340;
-               NV_DEBUG_KMS(dev, "Using default load_pattern of %d\n",
+               NV_DEBUG(drm, "Using default load_pattern of %d\n",
                         load_pattern);
        }
 
-       nv_wr32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or),
+       nv_wr32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or),
                NV50_PDISPLAY_DAC_LOAD_CTRL_ACTIVE | load_pattern);
        mdelay(45); /* give it some time to process */
-       load_state = nv_rd32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or));
+       load_state = nv_rd32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or));
 
-       nv_wr32(dev, NV50_PDISPLAY_DAC_LOAD_CTRL(or), 0);
-       nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or), dpms_state |
+       nv_wr32(device, NV50_PDISPLAY_DAC_LOAD_CTRL(or), 0);
+       nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or), dpms_state |
                NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
 
        if ((load_state & NV50_PDISPLAY_DAC_LOAD_CTRL_PRESENT) ==
@@ -111,9 +114,9 @@ nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
                status = connector_status_connected;
 
        if (status == connector_status_connected)
-               NV_DEBUG_KMS(dev, "Load was detected on output with or %d\n", or);
+               NV_DEBUG(drm, "Load was detected on output with or %d\n", or);
        else
-               NV_DEBUG_KMS(dev, "Load was not detected on output with or %d\n", or);
+               NV_DEBUG(drm, "Load was not detected on output with or %d\n", or);
 
        return status;
 }
@@ -121,23 +124,24 @@ nv50_dac_detect(struct drm_encoder *encoder, struct drm_connector *connector)
 static void
 nv50_dac_dpms(struct drm_encoder *encoder, int mode)
 {
-       struct drm_device *dev = encoder->dev;
+       struct nouveau_device *device = nouveau_dev(encoder->dev);
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
        struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
        uint32_t val;
        int or = nv_encoder->or;
 
-       NV_DEBUG_KMS(dev, "or %d mode %d\n", or, mode);
+       NV_DEBUG(drm, "or %d mode %d\n", or, mode);
 
        /* wait for it to be done */
-       if (!nv_wait(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
+       if (!nv_wait(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or),
                     NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING, 0)) {
-               NV_ERROR(dev, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
-               NV_ERROR(dev, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
-                        nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
+               NV_ERROR(drm, "timeout: DAC_DPMS_CTRL_PENDING(%d) == 0\n", or);
+               NV_ERROR(drm, "DAC_DPMS_CTRL(%d) = 0x%08x\n", or,
+                        nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)));
                return;
        }
 
-       val = nv_rd32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or)) & ~0x7F;
+       val = nv_rd32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or)) & ~0x7F;
 
        if (mode != DRM_MODE_DPMS_ON)
                val |= NV50_PDISPLAY_DAC_DPMS_CTRL_BLANKED;
@@ -158,20 +162,22 @@ nv50_dac_dpms(struct drm_encoder *encoder, int mode)
                break;
        }
 
-       nv_wr32(dev, NV50_PDISPLAY_DAC_DPMS_CTRL(or), val |
+       nv_wr32(device, NV50_PDISPLAY_DAC_DPMS_CTRL(or), val |
                NV50_PDISPLAY_DAC_DPMS_CTRL_PENDING);
 }
 
 static void
 nv50_dac_save(struct drm_encoder *encoder)
 {
-       NV_ERROR(encoder->dev, "!!\n");
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+       NV_ERROR(drm, "!!\n");
 }
 
 static void
 nv50_dac_restore(struct drm_encoder *encoder)
 {
-       NV_ERROR(encoder->dev, "!!\n");
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
+       NV_ERROR(drm, "!!\n");
 }
 
 static bool
@@ -179,14 +185,15 @@ nv50_dac_mode_fixup(struct drm_encoder *encoder,
                    const struct drm_display_mode *mode,
                    struct drm_display_mode *adjusted_mode)
 {
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
        struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
        struct nouveau_connector *connector;
 
-       NV_DEBUG_KMS(encoder->dev, "or %d\n", nv_encoder->or);
+       NV_DEBUG(drm, "or %d\n", nv_encoder->or);
 
        connector = nouveau_encoder_connector_get(nv_encoder);
        if (!connector) {
-               NV_ERROR(encoder->dev, "Encoder has no connector\n");
+               NV_ERROR(drm, "Encoder has no connector\n");
                return false;
        }
 
@@ -207,13 +214,14 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                  struct drm_display_mode *adjusted_mode)
 {
        struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
        struct drm_device *dev = encoder->dev;
        struct nouveau_channel *evo = nv50_display(dev)->master;
        struct nouveau_crtc *crtc = nouveau_crtc(encoder->crtc);
        uint32_t mode_ctl = 0, mode_ctl2 = 0;
        int ret;
 
-       NV_DEBUG_KMS(dev, "or %d type %d crtc %d\n",
+       NV_DEBUG(drm, "or %d type %d crtc %d\n",
                     nv_encoder->or, nv_encoder->dcb->type, crtc->index);
 
        nv50_dac_dpms(encoder, DRM_MODE_DPMS_ON);
@@ -224,10 +232,10 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
                mode_ctl |= NV50_EVO_DAC_MODE_CTRL_CRTC0;
 
        /* Lacking a working tv-out, this is not a 100% sure. */
-       if (nv_encoder->dcb->type == OUTPUT_ANALOG)
+       if (nv_encoder->dcb->type == DCB_OUTPUT_ANALOG)
                mode_ctl |= 0x40;
        else
-       if (nv_encoder->dcb->type == OUTPUT_TV)
+       if (nv_encoder->dcb->type == DCB_OUTPUT_TV)
                mode_ctl |= 0x100;
 
        if (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC)
@@ -238,7 +246,7 @@ nv50_dac_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
 
        ret = RING_SPACE(evo, 3);
        if (ret) {
-               NV_ERROR(dev, "no space while connecting DAC\n");
+               NV_ERROR(drm, "no space while connecting DAC\n");
                return;
        }
        BEGIN_NV04(evo, 0, NV50_EVO_DAC(nv_encoder->or, MODE_CTRL), 2);
@@ -271,11 +279,12 @@ static void
 nv50_dac_destroy(struct drm_encoder *encoder)
 {
        struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
+       struct nouveau_drm *drm = nouveau_drm(encoder->dev);
 
        if (!encoder)
                return;
 
-       NV_DEBUG_KMS(encoder->dev, "\n");
+       NV_DEBUG(drm, "\n");
 
        drm_encoder_cleanup(encoder);
        kfree(nv_encoder);
@@ -286,7 +295,7 @@ static const struct drm_encoder_funcs nv50_dac_encoder_funcs = {
 };
 
 int
-nv50_dac_create(struct drm_connector *connector, struct dcb_entry *entry)
+nv50_dac_create(struct drm_connector *connector, struct dcb_output *entry)
 {
        struct nouveau_encoder *nv_encoder;
        struct drm_encoder *encoder;