static void dmub_hpd_sense_callback(struct amdgpu_device *adev,
                              struct dmub_notification *notify)
 {
-       DRM_DEBUG_DRIVER("DMUB HPD SENSE callback.\n");
+       drm_dbg_driver(adev_to_drm(adev), "DMUB HPD SENSE callback.\n");
 }
 
 /**
                        trace_amdgpu_dmub_trace_high_irq(entry.trace_code, entry.tick_count,
                                                        entry.param0, entry.param1);
 
-                       DRM_DEBUG_DRIVER("trace_code:%u, tick_count:%u, param0:%u, param1:%u\n",
+                       drm_dbg_driver(adev_to_drm(adev), "trace_code:%u, tick_count:%u, param0:%u, param1:%u\n",
                                 entry.trace_code, entry.tick_count, entry.param0, entry.param1);
                } else
                        break;
        } while (count <= DMUB_TRACE_MAX_READ);
 
        if (count > DMUB_TRACE_MAX_READ)
-               DRM_DEBUG_DRIVER("Warning : count > DMUB_TRACE_MAX_READ");
+               drm_dbg_driver(adev_to_drm(adev), "Warning : count > DMUB_TRACE_MAX_READ");
 
        if (dc_enable_dmub_notifications(adev->dm.dc) &&
                irq_params->irq_src == DC_IRQ_SOURCE_DMCUB_OUTBOX) {
                drm_err(adev_to_drm(adev),
                "amdgpu: failed to initialize freesync_module.\n");
        } else
-               DRM_DEBUG_DRIVER("amdgpu: freesync_module init done %p.\n",
+               drm_dbg_driver(adev_to_drm(adev), "amdgpu: freesync_module init done %p.\n",
                                adev->dm.freesync_module);
 
        amdgpu_dm_init_color_mod();
                if (!adev->dm.hdcp_workqueue)
                        drm_err(adev_to_drm(adev), "amdgpu: failed to initialize hdcp_workqueue.\n");
                else
-                       DRM_DEBUG_DRIVER("amdgpu: hdcp_workqueue init done %p.\n", adev->dm.hdcp_workqueue);
+                       drm_dbg_driver(adev_to_drm(adev), "amdgpu: hdcp_workqueue init done %p.\n", adev->dm.hdcp_workqueue);
 
                dc_init_callbacks(adev->dm.dc, &init_params);
        }
 
 #endif
 
-       DRM_DEBUG_DRIVER("KMS initialized.\n");
+       drm_dbg_driver(adev_to_drm(adev), "KMS initialized.\n");
 
        return 0;
 error:
                drm_err(drm, "DM: Backlight registration failed!\n");
                dm->backlight_dev[aconnector->bl_idx] = NULL;
        } else
-               DRM_DEBUG_DRIVER("DM: Registered Backlight device: %s\n", bl_name);
+               drm_dbg_driver(drm, "DM: Registered Backlight device: %s\n", bl_name);
 }
 
 static int initialize_plane(struct amdgpu_display_manager *dm,
                m_pref = list_first_entry_or_null(
                                &aconnector->base.modes, struct drm_display_mode, head);
                if (!m_pref) {
-                       DRM_DEBUG_DRIVER("No preferred mode found in EDID\n");
+                       drm_dbg_driver(aconnector->base.dev, "No preferred mode found in EDID\n");
                        return NULL;
                }
        }
                                                dc_link_get_highest_encoding_format(aconnector->dc_link),
                                                &stream->timing.dsc_cfg)) {
                                stream->timing.flags.DSC = 1;
-                               DRM_DEBUG_DRIVER("%s: SST_DSC [%s] DSC is selected from SST RX\n",
+                               drm_dbg_driver(drm_connector->dev, "%s: SST_DSC [%s] DSC is selected from SST RX\n",
                                                        __func__, drm_connector->name);
                        }
                } else if (sink->link->dpcd_caps.dongle_type == DISPLAY_DONGLE_DP_HDMI_CONVERTER) {
                                                dc_link_get_highest_encoding_format(aconnector->dc_link),
                                                &stream->timing.dsc_cfg)) {
                                        stream->timing.flags.DSC = 1;
-                                       DRM_DEBUG_DRIVER("%s: SST_DSC [%s] DSC is selected from DP-HDMI PCON\n",
+                                       drm_dbg_driver(drm_connector->dev, "%s: SST_DSC [%s] DSC is selected from DP-HDMI PCON\n",
                                                                         __func__, drm_connector->name);
                                }
                }
                 * case, we call set mode ourselves to restore the previous mode
                 * and the modelist may not be filled in time.
                 */
-               DRM_DEBUG_DRIVER("No preferred mode found\n");
+               drm_dbg_driver(dev, "No preferred mode found\n");
        } else if (aconnector) {
                recalculate_timing = amdgpu_freesync_vid_mode &&
                                 is_freesync_video_mode(&mode, aconnector);
                 */
                WARN_ON(amdgpu_dm_crtc_set_vupdate_irq(new_state->base.crtc, true) != 0);
                WARN_ON(drm_crtc_vblank_get(new_state->base.crtc) != 0);
-               DRM_DEBUG_DRIVER("%s: crtc=%u VRR off->on: Get vblank ref\n",
+               drm_dbg_driver(new_state->base.crtc->dev, "%s: crtc=%u VRR off->on: Get vblank ref\n",
                                 __func__, new_state->base.crtc->base.id);
        } else if (old_vrr_active && !new_vrr_active) {
                /* Transition VRR active -> inactive:
                 */
                WARN_ON(amdgpu_dm_crtc_set_vupdate_irq(new_state->base.crtc, false) != 0);
                drm_crtc_vblank_put(new_state->base.crtc);
-               DRM_DEBUG_DRIVER("%s: crtc=%u VRR on->off: Drop vblank ref\n",
+               drm_dbg_driver(new_state->base.crtc->dev, "%s: crtc=%u VRR on->off: Drop vblank ref\n",
                                 __func__, new_state->base.crtc->base.id);
        }
 }
        struct dm_atomic_state *dm_state = NULL;
        struct dm_crtc_state *dm_old_crtc_state, *dm_new_crtc_state;
        struct dc_stream_state *new_stream;
+       struct amdgpu_device *adev = dm->adev;
        int ret = 0;
 
        /*
                 */
 
                if (!new_stream) {
-                       DRM_DEBUG_DRIVER("%s: Failed to create new stream for crtc %d\n",
+                       drm_dbg_driver(adev_to_drm(adev), "%s: Failed to create new stream for crtc %d\n",
                                        __func__, acrtc->base.base.id);
                        ret = -ENOMEM;
                        goto fail;
                    dc_is_stream_unchanged(new_stream, dm_old_crtc_state->stream) &&
                    dc_is_stream_scaling_unchanged(new_stream, dm_old_crtc_state->stream)) {
                        new_crtc_state->mode_changed = false;
-                       DRM_DEBUG_DRIVER("Mode change not required, setting mode_changed to %d",
+                       drm_dbg_driver(adev_to_drm(adev), "Mode change not required, setting mode_changed to %d",
                                         new_crtc_state->mode_changed);
                }
        }
                    is_timing_unchanged_for_freesync(new_crtc_state,
                                                     old_crtc_state)) {
                        new_crtc_state->mode_changed = false;
-                       DRM_DEBUG_DRIVER(
+                       drm_dbg_driver(adev_to_drm(adev),
                                "Mode change not required for front porch change, setting mode_changed to %d",
                                new_crtc_state->mode_changed);
 
                if (ret)
                        goto fail;
 
-               DRM_DEBUG_DRIVER("Disabling DRM crtc: %d\n",
+               drm_dbg_driver(adev_to_drm(adev), "Disabling DRM crtc: %d\n",
                                crtc->base.id);
 
                /* i.e. reset mode */