}
 
 static int
-nv50_outp_acquire(struct nouveau_encoder *nv_encoder)
+nv50_outp_acquire(struct nouveau_encoder *nv_encoder, bool hda)
 {
        struct nouveau_drm *drm = nouveau_drm(nv_encoder->base.base.dev);
        struct nv50_disp *disp = nv50_disp(drm->dev);
                .base.method = NV50_DISP_MTHD_V1_ACQUIRE,
                .base.hasht  = nv_encoder->dcb->hasht,
                .base.hashm  = nv_encoder->dcb->hashm,
+               .info.hda = hda,
        };
        int ret;
 
        struct nv50_head_atom *asyh = nv50_head_atom(nv_crtc->base.state);
        struct nv50_core *core = nv50_disp(encoder->dev)->core;
 
-       nv50_outp_acquire(nv_encoder);
+       nv50_outp_acquire(nv_encoder, false);
 
        core->func->dac->ctrl(core, nv_encoder->or, 1 << nv_crtc->index, asyh);
        asyh->or.depth = 0;
                DRM_DEBUG_KMS("Failed to allocate VCPI\n");
 
        if (!mstm->links++)
-               nv50_outp_acquire(mstm->outp);
+               nv50_outp_acquire(mstm->outp, false /*XXX: MST audio.*/);
 
        if (mstm->outp->link & 1)
                proto = 0x8;
        struct nouveau_drm *drm = nouveau_drm(dev);
        struct nouveau_connector *nv_connector;
        struct nvbios *bios = &drm->vbios;
+       bool hda = false;
        u8 proto = 0xf;
        u8 depth = 0x0;
 
        nv_connector = nouveau_encoder_connector_get(nv_encoder);
        nv_encoder->crtc = encoder->crtc;
-       nv50_outp_acquire(nv_encoder);
+
+       if ((disp->disp->object.oclass == GT214_DISP ||
+            disp->disp->object.oclass >= GF110_DISP) &&
+           drm_detect_monitor_audio(nv_connector->edid))
+               hda = true;
+       nv50_outp_acquire(nv_encoder, hda);
 
        switch (nv_encoder->dcb->type) {
        case DCB_OUTPUT_TMDS:
        u8 owner = 1 << nv_crtc->index;
        u8 proto;
 
-       nv50_outp_acquire(nv_encoder);
+       nv50_outp_acquire(nv_encoder, false);
 
        switch (asyh->or.bpc) {
        case 10: asyh->or.depth = 0x6; break;
 
 void nvkm_outp_del(struct nvkm_outp **);
 void nvkm_outp_init(struct nvkm_outp *);
 void nvkm_outp_fini(struct nvkm_outp *);
-int nvkm_outp_acquire(struct nvkm_outp *, u8 user);
+int nvkm_outp_acquire(struct nvkm_outp *, u8 user, bool hda);
 void nvkm_outp_release(struct nvkm_outp *, u8 user);
 void nvkm_outp_route(struct nvkm_disp *);
 
 
                } *args = data;
                int ret = -ENOSYS;
                if (!(ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, false))) {
-                       ret = nvkm_outp_acquire(outp, NVKM_OUTP_USER);
+                       ret = nvkm_outp_acquire(outp, NVKM_OUTP_USER, args->v0.hda);
                        if (ret == 0) {
                                args->v0.or = outp->ior->id;
                                args->v0.link = outp->ior->asy.link;
                if (!(ret = nvif_unpack(ret, &data, &size, args->v0, 0, 0, false))) {
                        if (args->v0.data & 0xfff00000)
                                return -EINVAL;
-                       ret = nvkm_outp_acquire(outp, NVKM_OUTP_PRIV);
+                       ret = nvkm_outp_acquire(outp, NVKM_OUTP_PRIV, false);
                        if (ret)
                                return ret;
                        ret = outp->ior->func->sense(outp->ior, args->v0.data);