diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c
index 4df3911..fbc9cc1 100644
--- a/drivers/gpu/drm/tegra/dc.c
+++ b/drivers/gpu/drm/tegra/dc.c
@@ -1137,7 +1137,7 @@ static void tegra_dc_commit_state(struct tegra_dc *dc,
 
 	err = clk_set_parent(dc->clk, state->clk);
 	if (err < 0)
-		dev_err(dc->dev, "failed to set parent clock: %d\n", err);
+		DRM_DEV_ERROR(dc->dev, "failed to set parent clock: %d\n", err);
 
 	/*
 	 * Outputs may not want to change the parent clock rate. This is only
@@ -1150,7 +1150,7 @@ static void tegra_dc_commit_state(struct tegra_dc *dc,
 	if (state->pclk > 0) {
 		err = clk_set_rate(state->clk, state->pclk);
 		if (err < 0)
-			dev_err(dc->dev,
+			DRM_DEV_ERROR(dc->dev,
 				"failed to set clock rate to %lu Hz\n",
 				state->pclk);
 	}
@@ -1195,7 +1195,7 @@ static int tegra_dc_wait_idle(struct tegra_dc *dc, unsigned long timeout)
 		usleep_range(1000, 2000);
 	}
 
-	dev_dbg(dc->dev, "timeout waiting for DC to become idle\n");
+	DRM_DEV_DEBUG(dc->dev, "timeout waiting for DC to become idle\n");
 	return -ETIMEDOUT;
 }
 
@@ -1763,7 +1763,8 @@ static int tegra_dc_init(struct host1x_client *client)
 	if (tegra->domain) {
 		err = iommu_attach_device(tegra->domain, dc->dev);
 		if (err < 0) {
-			dev_err(dc->dev, "failed to attach to domain: %d\n",
+			DRM_DEV_ERROR(dc->dev,
+				"failed to attach to domain: %d\n",
 				err);
 			return err;
 		}
@@ -1801,7 +1802,8 @@ static int tegra_dc_init(struct host1x_client *client)
 
 	err = tegra_dc_rgb_init(drm, dc);
 	if (err < 0 && err != -ENODEV) {
-		dev_err(dc->dev, "failed to initialize RGB output: %d\n", err);
+		DRM_DEV_ERROR(dc->dev,
+			"failed to initialize RGB output: %d\n", err);
 		goto cleanup;
 	}
 
@@ -1812,13 +1814,15 @@ static int tegra_dc_init(struct host1x_client *client)
 	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
 		err = tegra_dc_debugfs_init(dc, drm->primary);
 		if (err < 0)
-			dev_err(dc->dev, "debugfs setup failed: %d\n", err);
+			DRM_DEV_ERROR(dc->dev,
+				"debugfs setup failed: %d\n", err);
 	}
 
 	err = devm_request_irq(dc->dev, dc->irq, tegra_dc_irq, 0,
 			       dev_name(dc->dev), dc);
 	if (err < 0) {
-		dev_err(dc->dev, "failed to request IRQ#%u: %d\n", dc->irq,
+		DRM_DEV_ERROR(dc->dev,
+			"failed to request IRQ#%u: %d\n", dc->irq,
 			err);
 		goto cleanup;
 	}
@@ -1850,12 +1854,14 @@ static int tegra_dc_exit(struct host1x_client *client)
 	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
 		err = tegra_dc_debugfs_exit(dc);
 		if (err < 0)
-			dev_err(dc->dev, "debugfs cleanup failed: %d\n", err);
+			DRM_DEV_ERROR(dc->dev,
+				"debugfs cleanup failed: %d\n", err);
 	}
 
 	err = tegra_dc_rgb_exit(dc);
 	if (err) {
-		dev_err(dc->dev, "failed to shutdown RGB output: %d\n", err);
+		DRM_DEV_ERROR(dc->dev,
+			"failed to shutdown RGB output: %d\n", err);
 		return err;
 	}
 
@@ -1954,7 +1960,7 @@ static int tegra_dc_parse_dt(struct tegra_dc *dc)
 
 	err = of_property_read_u32(dc->dev->of_node, "nvidia,head", &value);
 	if (err < 0) {
-		dev_err(dc->dev, "missing \"nvidia,head\" property\n");
+		DRM_DEV_ERROR(dc->dev, "missing \"nvidia,head\" property\n");
 
 		/*
 		 * If the nvidia,head property isn't present, try to find the
@@ -2009,13 +2015,13 @@ static int tegra_dc_probe(struct platform_device *pdev)
 
 	dc->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(dc->clk)) {
-		dev_err(&pdev->dev, "failed to get clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get clock\n");
 		return PTR_ERR(dc->clk);
 	}
 
 	dc->rst = devm_reset_control_get(&pdev->dev, "dc");
 	if (IS_ERR(dc->rst)) {
-		dev_err(&pdev->dev, "failed to get reset\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get reset\n");
 		return PTR_ERR(dc->rst);
 	}
 
@@ -2038,13 +2044,14 @@ static int tegra_dc_probe(struct platform_device *pdev)
 
 	dc->irq = platform_get_irq(pdev, 0);
 	if (dc->irq < 0) {
-		dev_err(&pdev->dev, "failed to get IRQ\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get IRQ\n");
 		return -ENXIO;
 	}
 
 	err = tegra_dc_rgb_probe(dc);
 	if (err < 0 && err != -ENODEV) {
-		dev_err(&pdev->dev, "failed to probe RGB output: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to probe RGB output: %d\n", err);
 		return err;
 	}
 
@@ -2057,7 +2064,8 @@ static int tegra_dc_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&dc->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -2072,14 +2080,16 @@ static int tegra_dc_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&dc->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
 
 	err = tegra_dc_rgb_remove(dc);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to remove RGB output: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to remove RGB output: %d\n", err);
 		return err;
 	}
 
@@ -2097,7 +2107,7 @@ static int tegra_dc_suspend(struct device *dev)
 	if (!dc->soc->broken_reset) {
 		err = reset_control_assert(dc->rst);
 		if (err < 0) {
-			dev_err(dev, "failed to assert reset: %d\n", err);
+			DRM_DEV_ERROR(dev, "failed to assert reset: %d\n", err);
 			return err;
 		}
 	}
@@ -2119,20 +2129,21 @@ static int tegra_dc_resume(struct device *dev)
 		err = tegra_powergate_sequence_power_up(dc->powergate, dc->clk,
 							dc->rst);
 		if (err < 0) {
-			dev_err(dev, "failed to power partition: %d\n", err);
+			DRM_DEV_ERROR(dev,
+				"failed to power partition: %d\n", err);
 			return err;
 		}
 	} else {
 		err = clk_prepare_enable(dc->clk);
 		if (err < 0) {
-			dev_err(dev, "failed to enable clock: %d\n", err);
+			DRM_DEV_ERROR(dev, "failed to enable clock: %d\n", err);
 			return err;
 		}
 
 		if (!dc->soc->broken_reset) {
 			err = reset_control_deassert(dc->rst);
 			if (err < 0) {
-				dev_err(dev,
+				DRM_DEV_ERROR(dev,
 					"failed to deassert reset: %d\n", err);
 				return err;
 			}
diff --git a/drivers/gpu/drm/tegra/dpaux.c b/drivers/gpu/drm/tegra/dpaux.c
index e4da041..8a6a77b 100644
--- a/drivers/gpu/drm/tegra/dpaux.c
+++ b/drivers/gpu/drm/tegra/dpaux.c
@@ -446,14 +446,14 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 
 	dpaux->irq = platform_get_irq(pdev, 0);
 	if (dpaux->irq < 0) {
-		dev_err(&pdev->dev, "failed to get IRQ\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get IRQ\n");
 		return -ENXIO;
 	}
 
 	if (!pdev->dev.pm_domain) {
 		dpaux->rst = devm_reset_control_get(&pdev->dev, "dpaux");
 		if (IS_ERR(dpaux->rst)) {
-			dev_err(&pdev->dev,
+			DRM_DEV_ERROR(&pdev->dev,
 				"failed to get reset control: %ld\n",
 				PTR_ERR(dpaux->rst));
 			return PTR_ERR(dpaux->rst);
@@ -462,14 +462,14 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 
 	dpaux->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(dpaux->clk)) {
-		dev_err(&pdev->dev, "failed to get module clock: %ld\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to get module clock: %ld\n",
 			PTR_ERR(dpaux->clk));
 		return PTR_ERR(dpaux->clk);
 	}
 
 	err = clk_prepare_enable(dpaux->clk);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to enable module clock: %d\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to enable module clock: %d\n",
 			err);
 		return err;
 	}
@@ -479,7 +479,7 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 
 	dpaux->clk_parent = devm_clk_get(&pdev->dev, "parent");
 	if (IS_ERR(dpaux->clk_parent)) {
-		dev_err(&pdev->dev, "failed to get parent clock: %ld\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to get parent clock: %ld\n",
 			PTR_ERR(dpaux->clk_parent));
 		err = PTR_ERR(dpaux->clk_parent);
 		goto assert_reset;
@@ -487,21 +487,22 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 
 	err = clk_prepare_enable(dpaux->clk_parent);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to enable parent clock: %d\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to enable parent clock: %d\n",
 			err);
 		goto assert_reset;
 	}
 
 	err = clk_set_rate(dpaux->clk_parent, 270000000);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to set clock to 270 MHz: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to set clock to 270 MHz: %d\n",
 			err);
 		goto disable_parent_clk;
 	}
 
 	dpaux->vdd = devm_regulator_get(&pdev->dev, "vdd");
 	if (IS_ERR(dpaux->vdd)) {
-		dev_err(&pdev->dev, "failed to get VDD supply: %ld\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to get VDD supply: %ld\n",
 			PTR_ERR(dpaux->vdd));
 		err = PTR_ERR(dpaux->vdd);
 		goto disable_parent_clk;
@@ -510,7 +511,7 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 	err = devm_request_irq(dpaux->dev, dpaux->irq, tegra_dpaux_irq, 0,
 			       dev_name(dpaux->dev), dpaux);
 	if (err < 0) {
-		dev_err(dpaux->dev, "failed to request IRQ#%u: %d\n",
+		DRM_DEV_ERROR(dpaux->dev, "failed to request IRQ#%u: %d\n",
 			dpaux->irq, err);
 		goto disable_parent_clk;
 	}
@@ -546,7 +547,7 @@ static int tegra_dpaux_probe(struct platform_device *pdev)
 
 	dpaux->pinctrl = devm_pinctrl_register(&pdev->dev, &dpaux->desc, dpaux);
 	if (IS_ERR(dpaux->pinctrl)) {
-		dev_err(&pdev->dev, "failed to register pincontrol\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to register pincontrol\n");
 		return PTR_ERR(dpaux->pinctrl);
 	}
 #endif
@@ -779,7 +780,8 @@ int drm_dp_aux_train(struct drm_dp_aux *aux, struct drm_dp_link *link,
 		break;
 
 	default:
-		dev_err(aux->dev, "unsupported training pattern %u\n", tp);
+		DRM_DEV_ERROR(aux->dev,
+			"unsupported training pattern %u\n", tp);
 		return -EINVAL;
 	}
 
diff --git a/drivers/gpu/drm/tegra/dsi.c b/drivers/gpu/drm/tegra/dsi.c
index 046649e..f9e4ad3 100644
--- a/drivers/gpu/drm/tegra/dsi.c
+++ b/drivers/gpu/drm/tegra/dsi.c
@@ -854,7 +854,8 @@ static void tegra_dsi_unprepare(struct tegra_dsi *dsi)
 
 	err = tegra_mipi_disable(dsi->mipi);
 	if (err < 0)
-		dev_err(dsi->dev, "failed to disable MIPI calibration: %d\n",
+		DRM_DEV_ERROR(dsi->dev,
+		"failed to disable MIPI calibration: %d\n",
 			err);
 
 	pm_runtime_put(dsi->dev);
@@ -887,7 +888,7 @@ static void tegra_dsi_encoder_disable(struct drm_encoder *encoder)
 
 	err = tegra_dsi_wait_idle(dsi, 100);
 	if (err < 0)
-		dev_dbg(dsi->dev, "failed to idle DSI: %d\n", err);
+		DRM_DEV_DEBUG(dsi->dev, "failed to idle DSI: %d\n", err);
 
 	tegra_dsi_soft_reset(dsi);
 
@@ -907,12 +908,13 @@ static void tegra_dsi_prepare(struct tegra_dsi *dsi)
 
 	err = tegra_mipi_enable(dsi->mipi);
 	if (err < 0)
-		dev_err(dsi->dev, "failed to enable MIPI calibration: %d\n",
+		DRM_DEV_ERROR(dsi->dev,
+			"failed to enable MIPI calibration: %d\n",
 			err);
 
 	err = tegra_dsi_pad_calibrate(dsi);
 	if (err < 0)
-		dev_err(dsi->dev, "MIPI calibration failed: %d\n", err);
+		DRM_DEV_ERROR(dsi->dev, "MIPI calibration failed: %d\n", err);
 
 	if (dsi->slave)
 		tegra_dsi_prepare(dsi->slave);
@@ -1006,7 +1008,8 @@ static void tegra_dsi_encoder_enable(struct drm_encoder *encoder)
 
 	err = mipi_dphy_timing_validate(&state->timing, state->period);
 	if (err < 0) {
-		dev_err(dsi->dev, "failed to validate D-PHY timing: %d\n", err);
+		DRM_DEV_ERROR(dsi->dev,
+			"failed to validate D-PHY timing: %d\n", err);
 		return err;
 	}
 
@@ -1032,7 +1035,8 @@ static void tegra_dsi_encoder_enable(struct drm_encoder *encoder)
 	err = tegra_dc_state_setup_clock(dc, crtc_state, dsi->clk_parent,
 					 plld, scdiv);
 	if (err < 0) {
-		dev_err(output->dev, "failed to setup CRTC state: %d\n", err);
+		DRM_DEV_ERROR(output->dev,
+			"failed to setup CRTC state: %d\n", err);
 		return err;
 	}
 
@@ -1074,7 +1078,8 @@ static int tegra_dsi_init(struct host1x_client *client)
 
 		err = tegra_output_init(drm, &dsi->output);
 		if (err < 0)
-			dev_err(dsi->dev, "failed to initialize output: %d\n",
+			DRM_DEV_ERROR(dsi->dev,
+				"failed to initialize output: %d\n",
 				err);
 
 		dsi->output.encoder.possible_crtcs = 0x3;
@@ -1083,7 +1088,8 @@ static int tegra_dsi_init(struct host1x_client *client)
 	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
 		err = tegra_dsi_debugfs_init(dsi, drm->primary);
 		if (err < 0)
-			dev_err(dsi->dev, "debugfs setup failed: %d\n", err);
+			DRM_DEV_ERROR(dsi->dev,
+				"debugfs setup failed: %d\n", err);
 	}
 
 	return 0;
@@ -1159,11 +1165,11 @@ static ssize_t tegra_dsi_read_response(struct tegra_dsi *dsi,
 	switch (value & 0x3f) {
 	case MIPI_DSI_RX_ACKNOWLEDGE_AND_ERROR_REPORT:
 		errors = (value >> 8) & 0xffff;
-		dev_dbg(dsi->dev, "Acknowledge and error report: %04x\n",
+		DRM_DEV_DEBUG(dsi->dev, "Acknowledge and error report: %04x\n",
 			errors);
 		for (i = 0; i < ARRAY_SIZE(error_report); i++)
 			if (errors & BIT(i))
-				dev_dbg(dsi->dev, "  %2u: %s\n", i,
+				DRM_DEV_DEBUG(dsi->dev, "  %2u: %s\n", i,
 					error_report[i]);
 		break;
 
@@ -1187,7 +1193,7 @@ static ssize_t tegra_dsi_read_response(struct tegra_dsi *dsi,
 		break;
 
 	default:
-		dev_err(dsi->dev, "unhandled response type: %02x\n",
+		DRM_DEV_ERROR(dsi->dev, "unhandled response type: %02x\n",
 			value & 0x3f);
 		return -EPROTO;
 	}
@@ -1361,14 +1367,15 @@ static ssize_t tegra_dsi_host_transfer(struct mipi_dsi_host *host,
 			break;
 
 		default:
-			dev_err(dsi->dev, "unknown status: %08x\n", value);
+			DRM_DEV_ERROR(dsi->dev,
+				"unknown status: %08x\n", value);
 			break;
 		}
 
 		if (count > 1) {
 			err = tegra_dsi_read_response(dsi, msg, count);
 			if (err < 0)
-				dev_err(dsi->dev,
+				DRM_DEV_ERROR(dsi->dev,
 					"failed to parse response: %zd\n",
 					err);
 			else {
@@ -1419,12 +1426,13 @@ static int tegra_dsi_host_attach(struct mipi_dsi_host *host,
 	if (dsi->slave) {
 		int err;
 
-		dev_dbg(dsi->dev, "attaching dual-channel device %s\n",
+		DRM_DEV_DEBUG(dsi->dev, "attaching dual-channel device %s\n",
 			dev_name(&device->dev));
 
 		err = tegra_dsi_ganged_setup(dsi);
 		if (err < 0) {
-			dev_err(dsi->dev, "failed to set up ganged mode: %d\n",
+			DRM_DEV_ERROR(dsi->dev,
+				"failed to set up ganged mode: %d\n",
 				err);
 			return err;
 		}
@@ -1530,31 +1538,31 @@ static int tegra_dsi_probe(struct platform_device *pdev)
 
 	dsi->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(dsi->clk)) {
-		dev_err(&pdev->dev, "cannot get DSI clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get DSI clock\n");
 		return PTR_ERR(dsi->clk);
 	}
 
 	dsi->clk_lp = devm_clk_get(&pdev->dev, "lp");
 	if (IS_ERR(dsi->clk_lp)) {
-		dev_err(&pdev->dev, "cannot get low-power clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get low-power clock\n");
 		return PTR_ERR(dsi->clk_lp);
 	}
 
 	dsi->clk_parent = devm_clk_get(&pdev->dev, "parent");
 	if (IS_ERR(dsi->clk_parent)) {
-		dev_err(&pdev->dev, "cannot get parent clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get parent clock\n");
 		return PTR_ERR(dsi->clk_parent);
 	}
 
 	dsi->vdd = devm_regulator_get(&pdev->dev, "avdd-dsi-csi");
 	if (IS_ERR(dsi->vdd)) {
-		dev_err(&pdev->dev, "cannot get VDD supply\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get VDD supply\n");
 		return PTR_ERR(dsi->vdd);
 	}
 
 	err = tegra_dsi_setup_clocks(dsi);
 	if (err < 0) {
-		dev_err(&pdev->dev, "cannot setup clocks\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot setup clocks\n");
 		return err;
 	}
 
@@ -1572,7 +1580,8 @@ static int tegra_dsi_probe(struct platform_device *pdev)
 
 	err = mipi_dsi_host_register(&dsi->host);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register DSI host: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register DSI host: %d\n", err);
 		goto mipi_free;
 	}
 
@@ -1585,7 +1594,8 @@ static int tegra_dsi_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&dsi->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register host1x client: %d\n",
 			err);
 		goto unregister;
 	}
@@ -1608,7 +1618,8 @@ static int tegra_dsi_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&dsi->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -1630,7 +1641,7 @@ static int tegra_dsi_suspend(struct device *dev)
 	if (dsi->rst) {
 		err = reset_control_assert(dsi->rst);
 		if (err < 0) {
-			dev_err(dev, "failed to assert reset: %d\n", err);
+			DRM_DEV_ERROR(dev, "failed to assert reset: %d\n", err);
 			return err;
 		}
 	}
@@ -1652,19 +1663,20 @@ static int tegra_dsi_resume(struct device *dev)
 
 	err = regulator_enable(dsi->vdd);
 	if (err < 0) {
-		dev_err(dsi->dev, "failed to enable VDD supply: %d\n", err);
+		DRM_DEV_ERROR(dsi->dev,
+			"failed to enable VDD supply: %d\n", err);
 		return err;
 	}
 
 	err = clk_prepare_enable(dsi->clk);
 	if (err < 0) {
-		dev_err(dev, "cannot enable DSI clock: %d\n", err);
+		DRM_DEV_ERROR(dev, "cannot enable DSI clock: %d\n", err);
 		goto disable_vdd;
 	}
 
 	err = clk_prepare_enable(dsi->clk_lp);
 	if (err < 0) {
-		dev_err(dev, "cannot enable low-power clock: %d\n", err);
+		DRM_DEV_ERROR(dev, "cannot enable low-power clock: %d\n", err);
 		goto disable_clk;
 	}
 
@@ -1673,7 +1685,7 @@ static int tegra_dsi_resume(struct device *dev)
 	if (dsi->rst) {
 		err = reset_control_deassert(dsi->rst);
 		if (err < 0) {
-			dev_err(dev, "cannot assert reset: %d\n", err);
+			DRM_DEV_ERROR(dev, "cannot assert reset: %d\n", err);
 			goto disable_clk_lp;
 		}
 	}
diff --git a/drivers/gpu/drm/tegra/falcon.c b/drivers/gpu/drm/tegra/falcon.c
index f685e729..28f788b 100644
--- a/drivers/gpu/drm/tegra/falcon.c
+++ b/drivers/gpu/drm/tegra/falcon.c
@@ -75,7 +75,7 @@ static void falcon_copy_firmware_image(struct falcon *falcon,
 			       falcon->firmware.size, DMA_TO_DEVICE);
 	err = dma_mapping_error(falcon->dev, daddr);
 	if (err) {
-		dev_err(falcon->dev, "failed to map firmware: %d\n", err);
+		DRM_DEV_ERROR(falcon->dev, "failed to map firmware: %d\n", err);
 		return;
 	}
 	dma_sync_single_for_device(falcon->dev, daddr,
@@ -91,19 +91,20 @@ static int falcon_parse_firmware_image(struct falcon *falcon)
 
 	/* endian problems would show up right here */
 	if (bin->magic != PCI_VENDOR_ID_NVIDIA) {
-		dev_err(falcon->dev, "incorrect firmware magic\n");
+		DRM_DEV_ERROR(falcon->dev, "incorrect firmware magic\n");
 		return -EINVAL;
 	}
 
 	/* currently only version 1 is supported */
 	if (bin->version != 1) {
-		dev_err(falcon->dev, "unsupported firmware version\n");
+		DRM_DEV_ERROR(falcon->dev, "unsupported firmware version\n");
 		return -EINVAL;
 	}
 
 	/* check that the firmware size is consistent */
 	if (bin->size > falcon->firmware.size) {
-		dev_err(falcon->dev, "firmware image size inconsistency\n");
+		DRM_DEV_ERROR(falcon->dev,
+			"firmware image size inconsistency\n");
 		return -EINVAL;
 	}
 
@@ -142,7 +143,7 @@ int falcon_load_firmware(struct falcon *falcon)
 	falcon->firmware.vaddr = falcon->ops->alloc(falcon, firmware->size,
 						    &falcon->firmware.paddr);
 	if (!falcon->firmware.vaddr) {
-		dev_err(falcon->dev, "dma memory mapping failed\n");
+		DRM_DEV_ERROR(falcon->dev, "dma memory mapping failed\n");
 		return -ENOMEM;
 	}
 
@@ -152,7 +153,7 @@ int falcon_load_firmware(struct falcon *falcon)
 	/* parse the image data */
 	err = falcon_parse_firmware_image(falcon);
 	if (err < 0) {
-		dev_err(falcon->dev, "failed to parse firmware image\n");
+		DRM_DEV_ERROR(falcon->dev, "failed to parse firmware image\n");
 		goto err_setup_firmware_image;
 	}
 
@@ -245,7 +246,8 @@ int falcon_boot(struct falcon *falcon)
 
 	err = falcon_wait_idle(falcon);
 	if (err < 0) {
-		dev_err(falcon->dev, "Falcon boot failed due to timeout\n");
+		DRM_DEV_ERROR(falcon->dev,
+			"Falcon boot failed due to timeout\n");
 		return err;
 	}
 
diff --git a/drivers/gpu/drm/tegra/fb.c b/drivers/gpu/drm/tegra/fb.c
index 80540c1..7478127 100644
--- a/drivers/gpu/drm/tegra/fb.c
+++ b/drivers/gpu/drm/tegra/fb.c
@@ -138,7 +138,8 @@ static struct tegra_fb *tegra_fb_alloc(struct drm_device *drm,
 
 	err = drm_framebuffer_init(drm, &fb->base, &tegra_fb_funcs);
 	if (err < 0) {
-		dev_err(drm->dev, "failed to initialize framebuffer: %d\n",
+		DRM_DEV_ERROR(drm->dev,
+			"failed to initialize framebuffer: %d\n",
 			err);
 		kfree(fb->planes);
 		kfree(fb);
@@ -241,7 +242,8 @@ static int tegra_fbdev_probe(struct drm_fb_helper *helper,
 
 	info = drm_fb_helper_alloc_fbi(helper);
 	if (IS_ERR(info)) {
-		dev_err(drm->dev, "failed to allocate framebuffer info\n");
+		DRM_DEV_ERROR(drm->dev,
+			"failed to allocate framebuffer info\n");
 		drm_gem_object_put_unlocked(&bo->gem);
 		return PTR_ERR(info);
 	}
@@ -249,7 +251,8 @@ static int tegra_fbdev_probe(struct drm_fb_helper *helper,
 	fbdev->fb = tegra_fb_alloc(drm, &cmd, &bo, 1);
 	if (IS_ERR(fbdev->fb)) {
 		err = PTR_ERR(fbdev->fb);
-		dev_err(drm->dev, "failed to allocate DRM framebuffer: %d\n",
+		DRM_DEV_ERROR(drm->dev,
+			"failed to allocate DRM framebuffer: %d\n",
 			err);
 		drm_gem_object_put_unlocked(&bo->gem);
 		return PTR_ERR(fbdev->fb);
@@ -273,7 +276,8 @@ static int tegra_fbdev_probe(struct drm_fb_helper *helper,
 		bo->vaddr = vmap(bo->pages, bo->num_pages, VM_MAP,
 				 pgprot_writecombine(PAGE_KERNEL));
 		if (!bo->vaddr) {
-			dev_err(drm->dev, "failed to vmap() framebuffer\n");
+			DRM_DEV_ERROR(drm->dev,
+				"failed to vmap() framebuffer\n");
 			err = -ENOMEM;
 			goto destroy;
 		}
@@ -302,7 +306,7 @@ static struct tegra_fbdev *tegra_fbdev_create(struct drm_device *drm)
 
 	fbdev = kzalloc(sizeof(*fbdev), GFP_KERNEL);
 	if (!fbdev) {
-		dev_err(drm->dev, "failed to allocate DRM fbdev\n");
+		DRM_DEV_ERROR(drm->dev, "failed to allocate DRM fbdev\n");
 		return ERR_PTR(-ENOMEM);
 	}
 
@@ -326,20 +330,22 @@ static int tegra_fbdev_init(struct tegra_fbdev *fbdev,
 
 	err = drm_fb_helper_init(drm, &fbdev->base, max_connectors);
 	if (err < 0) {
-		dev_err(drm->dev, "failed to initialize DRM FB helper: %d\n",
+		DRM_DEV_ERROR(drm->dev,
+			"failed to initialize DRM FB helper: %d\n",
 			err);
 		return err;
 	}
 
 	err = drm_fb_helper_single_add_all_connectors(&fbdev->base);
 	if (err < 0) {
-		dev_err(drm->dev, "failed to add connectors: %d\n", err);
+		DRM_DEV_ERROR(drm->dev, "failed to add connectors: %d\n", err);
 		goto fini;
 	}
 
 	err = drm_fb_helper_initial_config(&fbdev->base, preferred_bpp);
 	if (err < 0) {
-		dev_err(drm->dev, "failed to set initial configuration: %d\n",
+		DRM_DEV_ERROR(drm->dev,
+			"failed to set initial configuration: %d\n",
 			err);
 		goto fini;
 	}
diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c
index ab1e53d..3051f58 100644
--- a/drivers/gpu/drm/tegra/gem.c
+++ b/drivers/gpu/drm/tegra/gem.c
@@ -128,7 +128,8 @@ static int tegra_bo_iommu_map(struct tegra_drm *tegra, struct tegra_bo *bo)
 	err = drm_mm_insert_node_generic(&tegra->mm,
 					 bo->mm, bo->gem.size, PAGE_SIZE, 0, 0);
 	if (err < 0) {
-		dev_err(tegra->drm->dev, "out of I/O virtual memory: %zd\n",
+		DRM_DEV_ERROR(tegra->drm->dev,
+			"out of I/O virtual memory: %zd\n",
 			err);
 		goto unlock;
 	}
@@ -138,7 +139,8 @@ static int tegra_bo_iommu_map(struct tegra_drm *tegra, struct tegra_bo *bo)
 	err = iommu_map_sg(tegra->domain, bo->paddr, bo->sgt->sgl,
 			   bo->sgt->nents, prot);
 	if (err < 0) {
-		dev_err(tegra->drm->dev, "failed to map buffer: %zd\n", err);
+		DRM_DEV_ERROR(tegra->drm->dev,
+			"failed to map buffer: %zd\n", err);
 		goto remove;
 	}
 
@@ -268,7 +270,7 @@ static int tegra_bo_alloc(struct drm_device *drm, struct tegra_bo *bo)
 		bo->vaddr = dma_alloc_wc(drm->dev, size, &bo->paddr,
 					 GFP_KERNEL | __GFP_NOWARN);
 		if (!bo->vaddr) {
-			dev_err(drm->dev,
+			DRM_DEV_ERROR(drm->dev,
 				"failed to allocate buffer of size %zu\n",
 				size);
 			return -ENOMEM;
diff --git a/drivers/gpu/drm/tegra/gr2d.c b/drivers/gpu/drm/tegra/gr2d.c
index 6ea070d..8549dd7 100644
--- a/drivers/gpu/drm/tegra/gr2d.c
+++ b/drivers/gpu/drm/tegra/gr2d.c
@@ -164,13 +164,13 @@ static int gr2d_probe(struct platform_device *pdev)
 
 	gr2d->clk = devm_clk_get(dev, NULL);
 	if (IS_ERR(gr2d->clk)) {
-		dev_err(dev, "cannot get clock\n");
+		DRM_DEV_ERROR(dev, "cannot get clock\n");
 		return PTR_ERR(gr2d->clk);
 	}
 
 	err = clk_prepare_enable(gr2d->clk);
 	if (err) {
-		dev_err(dev, "cannot turn on clock\n");
+		DRM_DEV_ERROR(dev, "cannot turn on clock\n");
 		return err;
 	}
 
@@ -186,7 +186,8 @@ static int gr2d_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&gr2d->client.base);
 	if (err < 0) {
-		dev_err(dev, "failed to register host1x client: %d\n", err);
+		DRM_DEV_ERROR(dev,
+			"failed to register host1x client: %d\n", err);
 		clk_disable_unprepare(gr2d->clk);
 		return err;
 	}
@@ -207,7 +208,8 @@ static int gr2d_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&gr2d->client.base);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
diff --git a/drivers/gpu/drm/tegra/gr3d.c b/drivers/gpu/drm/tegra/gr3d.c
index cee2ab6..18e0b3a 100644
--- a/drivers/gpu/drm/tegra/gr3d.c
+++ b/drivers/gpu/drm/tegra/gr3d.c
@@ -256,27 +256,29 @@ static int gr3d_probe(struct platform_device *pdev)
 
 	gr3d->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(gr3d->clk)) {
-		dev_err(&pdev->dev, "cannot get clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get clock\n");
 		return PTR_ERR(gr3d->clk);
 	}
 
 	gr3d->rst = devm_reset_control_get(&pdev->dev, "3d");
 	if (IS_ERR(gr3d->rst)) {
-		dev_err(&pdev->dev, "cannot get reset\n");
+		DRM_DEV_ERROR(&pdev->dev, "cannot get reset\n");
 		return PTR_ERR(gr3d->rst);
 	}
 
 	if (of_device_is_compatible(np, "nvidia,tegra30-gr3d")) {
 		gr3d->clk_secondary = devm_clk_get(&pdev->dev, "3d2");
 		if (IS_ERR(gr3d->clk_secondary)) {
-			dev_err(&pdev->dev, "cannot get secondary clock\n");
+			DRM_DEV_ERROR(&pdev->dev,
+				"cannot get secondary clock\n");
 			return PTR_ERR(gr3d->clk_secondary);
 		}
 
 		gr3d->rst_secondary = devm_reset_control_get(&pdev->dev,
 								"3d2");
 		if (IS_ERR(gr3d->rst_secondary)) {
-			dev_err(&pdev->dev, "cannot get secondary reset\n");
+			DRM_DEV_ERROR(&pdev->dev,
+				"cannot get secondary reset\n");
 			return PTR_ERR(gr3d->rst_secondary);
 		}
 	}
@@ -284,7 +286,7 @@ static int gr3d_probe(struct platform_device *pdev)
 	err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_3D, gr3d->clk,
 						gr3d->rst);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to power up 3D unit\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to power up 3D unit\n");
 		return err;
 	}
 
@@ -293,7 +295,7 @@ static int gr3d_probe(struct platform_device *pdev)
 							gr3d->clk_secondary,
 							gr3d->rst_secondary);
 		if (err < 0) {
-			dev_err(&pdev->dev,
+			DRM_DEV_ERROR(&pdev->dev,
 				"failed to power up secondary 3D unit\n");
 			return err;
 		}
@@ -311,7 +313,8 @@ static int gr3d_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&gr3d->client.base);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -332,7 +335,8 @@ static int gr3d_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&gr3d->client.base);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
diff --git a/drivers/gpu/drm/tegra/hdmi.c b/drivers/gpu/drm/tegra/hdmi.c
index 5b9d83b..189fd8d 100644
--- a/drivers/gpu/drm/tegra/hdmi.c
+++ b/drivers/gpu/drm/tegra/hdmi.c
@@ -597,7 +597,7 @@ static int tegra_hdmi_setup_audio(struct tegra_hdmi *hdmi)
 	config = tegra_hdmi_get_audio_config(hdmi->audio_sample_rate,
 					     hdmi->pixel_clock);
 	if (!config) {
-		dev_err(hdmi->dev,
+		DRM_DEV_ERROR(hdmi->dev,
 			"cannot set audio to %u Hz at %u Hz pixel clock\n",
 			hdmi->audio_sample_rate, hdmi->pixel_clock);
 		return -EINVAL;
@@ -704,7 +704,7 @@ static void tegra_hdmi_write_infopack(struct tegra_hdmi *hdmi, const void *data,
 		break;
 
 	default:
-		dev_err(hdmi->dev, "unsupported infoframe type: %02x\n",
+		DRM_DEV_ERROR(hdmi->dev, "unsupported infoframe type: %02x\n",
 			ptr[0]);
 		return;
 	}
@@ -742,13 +742,15 @@ static void tegra_hdmi_setup_avi_infoframe(struct tegra_hdmi *hdmi,
 
 	err = drm_hdmi_avi_infoframe_from_display_mode(&frame, mode, false);
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to setup AVI infoframe: %zd\n", err);
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to setup AVI infoframe: %zd\n", err);
 		return;
 	}
 
 	err = hdmi_avi_infoframe_pack(&frame, buffer, sizeof(buffer));
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to pack AVI infoframe: %zd\n", err);
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to pack AVI infoframe: %zd\n", err);
 		return;
 	}
 
@@ -781,7 +783,8 @@ static void tegra_hdmi_setup_audio_infoframe(struct tegra_hdmi *hdmi)
 
 	err = hdmi_audio_infoframe_init(&frame);
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to setup audio infoframe: %zd\n",
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to setup audio infoframe: %zd\n",
 			err);
 		return;
 	}
@@ -790,7 +793,8 @@ static void tegra_hdmi_setup_audio_infoframe(struct tegra_hdmi *hdmi)
 
 	err = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer));
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to pack audio infoframe: %zd\n",
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to pack audio infoframe: %zd\n",
 			err);
 		return;
 	}
@@ -833,7 +837,8 @@ static void tegra_hdmi_setup_stereo_infoframe(struct tegra_hdmi *hdmi)
 
 	err = hdmi_vendor_infoframe_pack(&frame, buffer, sizeof(buffer));
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to pack vendor infoframe: %zd\n",
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to pack vendor infoframe: %zd\n",
 			err);
 		return;
 	}
@@ -1009,7 +1014,8 @@ static void tegra_hdmi_encoder_enable(struct drm_encoder *encoder)
 
 	err = clk_set_rate(hdmi->clk, hdmi->pixel_clock);
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to set HDMI clock frequency: %d\n",
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to set HDMI clock frequency: %d\n",
 			err);
 	}
 
@@ -1209,7 +1215,8 @@ static void tegra_hdmi_encoder_enable(struct drm_encoder *encoder)
 	err = tegra_dc_state_setup_clock(dc, crtc_state, hdmi->clk_parent,
 					 pclk, 0);
 	if (err < 0) {
-		dev_err(output->dev, "failed to setup CRTC state: %d\n", err);
+		DRM_DEV_ERROR(output->dev,
+			"failed to setup CRTC state: %d\n", err);
 		return err;
 	}
 
@@ -1496,7 +1503,8 @@ static int tegra_hdmi_init(struct host1x_client *client)
 
 	err = tegra_output_init(drm, &hdmi->output);
 	if (err < 0) {
-		dev_err(client->dev, "failed to initialize output: %d\n", err);
+		DRM_DEV_ERROR(client->dev,
+			"failed to initialize output: %d\n", err);
 		return err;
 	}
 
@@ -1505,25 +1513,29 @@ static int tegra_hdmi_init(struct host1x_client *client)
 	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
 		err = tegra_hdmi_debugfs_init(hdmi, drm->primary);
 		if (err < 0)
-			dev_err(client->dev, "debugfs setup failed: %d\n", err);
+			DRM_DEV_ERROR(client->dev,
+				"debugfs setup failed: %d\n", err);
 	}
 
 	err = regulator_enable(hdmi->hdmi);
 	if (err < 0) {
-		dev_err(client->dev, "failed to enable HDMI regulator: %d\n",
+		DRM_DEV_ERROR(client->dev,
+			"failed to enable HDMI regulator: %d\n",
 			err);
 		return err;
 	}
 
 	err = regulator_enable(hdmi->pll);
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to enable PLL regulator: %d\n", err);
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to enable PLL regulator: %d\n", err);
 		return err;
 	}
 
 	err = regulator_enable(hdmi->vdd);
 	if (err < 0) {
-		dev_err(hdmi->dev, "failed to enable VDD regulator: %d\n", err);
+		DRM_DEV_ERROR(hdmi->dev,
+			"failed to enable VDD regulator: %d\n", err);
 		return err;
 	}
 
@@ -1687,13 +1699,13 @@ static int tegra_hdmi_probe(struct platform_device *pdev)
 
 	hdmi->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(hdmi->clk)) {
-		dev_err(&pdev->dev, "failed to get clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get clock\n");
 		return PTR_ERR(hdmi->clk);
 	}
 
 	hdmi->rst = devm_reset_control_get(&pdev->dev, "hdmi");
 	if (IS_ERR(hdmi->rst)) {
-		dev_err(&pdev->dev, "failed to get reset\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get reset\n");
 		return PTR_ERR(hdmi->rst);
 	}
 
@@ -1703,25 +1715,25 @@ static int tegra_hdmi_probe(struct platform_device *pdev)
 
 	err = clk_set_parent(hdmi->clk, hdmi->clk_parent);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to setup clocks: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev, "failed to setup clocks: %d\n", err);
 		return err;
 	}
 
 	hdmi->hdmi = devm_regulator_get(&pdev->dev, "hdmi");
 	if (IS_ERR(hdmi->hdmi)) {
-		dev_err(&pdev->dev, "failed to get HDMI regulator\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get HDMI regulator\n");
 		return PTR_ERR(hdmi->hdmi);
 	}
 
 	hdmi->pll = devm_regulator_get(&pdev->dev, "pll");
 	if (IS_ERR(hdmi->pll)) {
-		dev_err(&pdev->dev, "failed to get PLL regulator\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get PLL regulator\n");
 		return PTR_ERR(hdmi->pll);
 	}
 
 	hdmi->vdd = devm_regulator_get(&pdev->dev, "vdd");
 	if (IS_ERR(hdmi->vdd)) {
-		dev_err(&pdev->dev, "failed to get VDD regulator\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get VDD regulator\n");
 		return PTR_ERR(hdmi->vdd);
 	}
 
@@ -1745,7 +1757,7 @@ static int tegra_hdmi_probe(struct platform_device *pdev)
 	err = devm_request_irq(hdmi->dev, hdmi->irq, tegra_hdmi_irq, 0,
 			       dev_name(hdmi->dev), hdmi);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to request IRQ#%u: %d\n",
+		DRM_DEV_ERROR(&pdev->dev, "failed to request IRQ#%u: %d\n",
 			hdmi->irq, err);
 		return err;
 	}
@@ -1759,7 +1771,8 @@ static int tegra_hdmi_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&hdmi->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -1776,7 +1789,8 @@ static int tegra_hdmi_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&hdmi->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -1794,7 +1808,7 @@ static int tegra_hdmi_suspend(struct device *dev)
 
 	err = reset_control_assert(hdmi->rst);
 	if (err < 0) {
-		dev_err(dev, "failed to assert reset: %d\n", err);
+		DRM_DEV_ERROR(dev, "failed to assert reset: %d\n", err);
 		return err;
 	}
 
@@ -1812,7 +1826,7 @@ static int tegra_hdmi_resume(struct device *dev)
 
 	err = clk_prepare_enable(hdmi->clk);
 	if (err < 0) {
-		dev_err(dev, "failed to enable clock: %d\n", err);
+		DRM_DEV_ERROR(dev, "failed to enable clock: %d\n", err);
 		return err;
 	}
 
@@ -1820,7 +1834,7 @@ static int tegra_hdmi_resume(struct device *dev)
 
 	err = reset_control_deassert(hdmi->rst);
 	if (err < 0) {
-		dev_err(dev, "failed to deassert reset: %d\n", err);
+		DRM_DEV_ERROR(dev, "failed to deassert reset: %d\n", err);
 		clk_disable_unprepare(hdmi->clk);
 		return err;
 	}
diff --git a/drivers/gpu/drm/tegra/output.c b/drivers/gpu/drm/tegra/output.c
index 595d1ec..7c5fbfe 100644
--- a/drivers/gpu/drm/tegra/output.c
+++ b/drivers/gpu/drm/tegra/output.c
@@ -132,13 +132,14 @@ int tegra_output_probe(struct tegra_output *output)
 		err = gpio_request_one(output->hpd_gpio, GPIOF_DIR_IN,
 				       "HDMI hotplug detect");
 		if (err < 0) {
-			dev_err(output->dev, "gpio_request_one(): %d\n", err);
+			DRM_DEV_ERROR(output->dev,
+				"gpio_request_one(): %d\n", err);
 			return err;
 		}
 
 		err = gpio_to_irq(output->hpd_gpio);
 		if (err < 0) {
-			dev_err(output->dev, "gpio_to_irq(): %d\n", err);
+			DRM_DEV_ERROR(output->dev, "gpio_to_irq(): %d\n", err);
 			gpio_free(output->hpd_gpio);
 			return err;
 		}
@@ -151,7 +152,8 @@ int tegra_output_probe(struct tegra_output *output)
 		err = request_threaded_irq(output->hpd_irq, NULL, hpd_irq,
 					   flags, "hpd", output);
 		if (err < 0) {
-			dev_err(output->dev, "failed to request IRQ#%u: %d\n",
+			DRM_DEV_ERROR(output->dev,
+				"failed to request IRQ#%u: %d\n",
 				output->hpd_irq, err);
 			gpio_free(output->hpd_gpio);
 			return err;
diff --git a/drivers/gpu/drm/tegra/rgb.c b/drivers/gpu/drm/tegra/rgb.c
index 78ec519..1dc536e 100644
--- a/drivers/gpu/drm/tegra/rgb.c
+++ b/drivers/gpu/drm/tegra/rgb.c
@@ -201,7 +201,8 @@ static void tegra_rgb_encoder_enable(struct drm_encoder *encoder)
 	err = tegra_dc_state_setup_clock(dc, crtc_state, rgb->clk_parent,
 					 pclk, div);
 	if (err < 0) {
-		dev_err(output->dev, "failed to setup CRTC state: %d\n", err);
+		DRM_DEV_ERROR(output->dev,
+			"failed to setup CRTC state: %d\n", err);
 		return err;
 	}
 
@@ -238,19 +239,19 @@ int tegra_dc_rgb_probe(struct tegra_dc *dc)
 
 	rgb->clk = devm_clk_get(dc->dev, NULL);
 	if (IS_ERR(rgb->clk)) {
-		dev_err(dc->dev, "failed to get clock\n");
+		DRM_DEV_ERROR(dc->dev, "failed to get clock\n");
 		return PTR_ERR(rgb->clk);
 	}
 
 	rgb->clk_parent = devm_clk_get(dc->dev, "parent");
 	if (IS_ERR(rgb->clk_parent)) {
-		dev_err(dc->dev, "failed to get parent clock\n");
+		DRM_DEV_ERROR(dc->dev, "failed to get parent clock\n");
 		return PTR_ERR(rgb->clk_parent);
 	}
 
 	err = clk_set_parent(rgb->clk, rgb->clk_parent);
 	if (err < 0) {
-		dev_err(dc->dev, "failed to set parent clock: %d\n", err);
+		DRM_DEV_ERROR(dc->dev, "failed to set parent clock: %d\n", err);
 		return err;
 	}
 
@@ -295,7 +296,8 @@ int tegra_dc_rgb_init(struct drm_device *drm, struct tegra_dc *dc)
 
 	err = tegra_output_init(drm, output);
 	if (err < 0) {
-		dev_err(output->dev, "failed to initialize output: %d\n", err);
+		DRM_DEV_ERROR(output->dev,
+			"failed to initialize output: %d\n", err);
 		return err;
 	}
 
diff --git a/drivers/gpu/drm/tegra/sor.c b/drivers/gpu/drm/tegra/sor.c
index 7ab1d1d..b6966d5 100644
--- a/drivers/gpu/drm/tegra/sor.c
+++ b/drivers/gpu/drm/tegra/sor.c
@@ -751,7 +751,7 @@ static int tegra_sor_compute_config(struct tegra_sor *sor,
 		config->tu_size = params.tu_size;
 	}
 
-	dev_dbg(sor->dev,
+	DRM_DEV_DEBUG(sor->dev,
 		"polarity: %d active count: %d tu size: %d active frac: %d\n",
 		config->active_polarity, config->active_count,
 		config->tu_size, config->active_frac);
@@ -766,12 +766,12 @@ static int tegra_sor_compute_config(struct tegra_sor *sor,
 
 	if (config->watermark > 30) {
 		config->watermark = 30;
-		dev_err(sor->dev,
+		DRM_DEV_ERROR(sor->dev,
 			"unable to compute TU size, forcing watermark to %u\n",
 			config->watermark);
 	} else if (config->watermark > num_syms_per_line) {
 		config->watermark = num_syms_per_line;
-		dev_err(sor->dev, "watermark too high, forcing to %u\n",
+		DRM_DEV_ERROR(sor->dev, "watermark too high, forcing to %u\n",
 			config->watermark);
 	}
 
@@ -789,7 +789,8 @@ static int tegra_sor_compute_config(struct tegra_sor *sor,
 	config->vblank_symbols = div_u64(num, pclk);
 	config->vblank_symbols -= 36 / link->num_lanes + 4;
 
-	dev_dbg(sor->dev, "blank symbols: H:%u V:%u\n", config->hblank_symbols,
+	DRM_DEV_DEBUG(sor->dev,
+		"blank symbols: H:%u V:%u\n", config->hblank_symbols,
 		config->vblank_symbols);
 
 	return 0;
@@ -999,7 +1000,8 @@ static int tegra_sor_power_down(struct tegra_sor *sor)
 	/* switch to safe parent clock */
 	err = tegra_sor_set_parent_clock(sor, sor->clk_safe);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set safe parent clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set safe parent clock: %d\n", err);
 
 	value = tegra_sor_readl(sor, SOR_DP_PADCTL0);
 	value &= ~(SOR_DP_PADCTL_PD_TXD_3 | SOR_DP_PADCTL_PD_TXD_0 |
@@ -1404,7 +1406,7 @@ static void tegra_sor_edp_disable(struct drm_encoder *encoder)
 
 	err = tegra_sor_detach(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to detach SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to detach SOR: %d\n", err);
 
 	tegra_sor_writel(sor, 0, SOR_STATE1);
 	tegra_sor_update(sor);
@@ -1423,17 +1425,19 @@ static void tegra_sor_edp_disable(struct drm_encoder *encoder)
 
 	err = tegra_sor_power_down(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power down SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to power down SOR: %d\n", err);
 
 	if (sor->aux) {
 		err = drm_dp_aux_disable(sor->aux);
 		if (err < 0)
-			dev_err(sor->dev, "failed to disable DP: %d\n", err);
+			DRM_DEV_ERROR(sor->dev,
+				"failed to disable DP: %d\n", err);
 	}
 
 	err = tegra_io_rail_power_off(TEGRA_IO_RAIL_LVDS);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power off I/O rail: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to power off I/O rail: %d\n", err);
 
 	if (output->panel)
 		drm_panel_unprepare(output->panel);
@@ -1506,25 +1510,27 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 
 	err = drm_dp_aux_enable(sor->aux);
 	if (err < 0)
-		dev_err(sor->dev, "failed to enable DP: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to enable DP: %d\n", err);
 
 	err = drm_dp_link_probe(sor->aux, &link);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to probe eDP link: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to probe eDP link: %d\n", err);
 		return;
 	}
 
 	/* switch to safe parent clock */
 	err = tegra_sor_set_parent_clock(sor, sor->clk_safe);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set safe parent clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set safe parent clock: %d\n", err);
 
 	memset(&config, 0, sizeof(config));
 	config.bits_per_pixel = state->bpc * 3;
 
 	err = tegra_sor_compute_config(sor, mode, &config, &link);
 	if (err < 0)
-		dev_err(sor->dev, "failed to compute configuration: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to compute configuration: %d\n", err);
 
 	value = tegra_sor_readl(sor, SOR_CLK_CNTRL);
 	value &= ~SOR_CLK_CNTRL_DP_CLK_SEL_MASK;
@@ -1593,7 +1599,8 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 	/* step 2 */
 	err = tegra_io_rail_power_on(TEGRA_IO_RAIL_LVDS);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power on I/O rail: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to power on I/O rail: %d\n", err);
 
 	usleep_range(5, 100);
 
@@ -1632,7 +1639,8 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 	/* switch to DP parent clock */
 	err = tegra_sor_set_parent_clock(sor, sor->clk_dp);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set parent clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set parent clock: %d\n", err);
 
 	/* power DP lanes */
 	value = tegra_sor_readl(sor, SOR_DP_PADCTL0);
@@ -1702,15 +1710,18 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 
 	err = drm_dp_link_probe(sor->aux, &link);
 	if (err < 0)
-		dev_err(sor->dev, "failed to probe eDP link: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to probe eDP link: %d\n", err);
 
 	err = drm_dp_link_power_up(sor->aux, &link);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power up eDP link: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to power up eDP link: %d\n", err);
 
 	err = drm_dp_link_configure(sor->aux, &link);
 	if (err < 0)
-		dev_err(sor->dev, "failed to configure eDP link: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to configure eDP link: %d\n", err);
 
 	rate = drm_dp_link_rate_to_bw_code(link.rate);
 	lanes = link.num_lanes;
@@ -1742,13 +1753,14 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 
 	err = tegra_sor_dp_train_fast(sor, &link);
 	if (err < 0)
-		dev_err(sor->dev, "DP fast link training failed: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"DP fast link training failed: %d\n", err);
 
-	dev_dbg(sor->dev, "fast link training succeeded\n");
+	DRM_DEV_DEBUG(sor->dev, "fast link training succeeded\n");
 
 	err = tegra_sor_power_up(sor, 250);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power up SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to power up SOR: %d\n", err);
 
 	/* CSTM (LVDS, link A/B, upper) */
 	value = SOR_CSTM_LVDS | SOR_CSTM_LINK_ACT_A | SOR_CSTM_LINK_ACT_B |
@@ -1766,7 +1778,7 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 	/* PWM setup */
 	err = tegra_sor_setup_pwm(sor, 250);
 	if (err < 0)
-		dev_err(sor->dev, "failed to setup PWM: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to setup PWM: %d\n", err);
 
 	tegra_sor_update(sor);
 
@@ -1778,11 +1790,11 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 
 	err = tegra_sor_attach(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to attach SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to attach SOR: %d\n", err);
 
 	err = tegra_sor_wakeup(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to enable DC: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to enable DC: %d\n", err);
 
 	if (output->panel)
 		drm_panel_enable(output->panel);
@@ -1806,7 +1818,8 @@ static void tegra_sor_edp_enable(struct drm_encoder *encoder)
 	err = tegra_dc_state_setup_clock(dc, crtc_state, sor->clk_parent,
 					 pclk, 0);
 	if (err < 0) {
-		dev_err(output->dev, "failed to setup CRTC state: %d\n", err);
+		DRM_DEV_ERROR(output->dev,
+			"failed to setup CRTC state: %d\n", err);
 		return err;
 	}
 
@@ -1864,7 +1877,7 @@ static void tegra_sor_hdmi_write_infopack(struct tegra_sor *sor,
 		break;
 
 	default:
-		dev_err(sor->dev, "unsupported infoframe type: %02x\n",
+		DRM_DEV_ERROR(sor->dev, "unsupported infoframe type: %02x\n",
 			ptr[0]);
 		return;
 	}
@@ -1911,13 +1924,15 @@ static void tegra_sor_hdmi_write_infopack(struct tegra_sor *sor,
 
 	err = drm_hdmi_avi_infoframe_from_display_mode(&frame, mode, false);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to setup AVI infoframe: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to setup AVI infoframe: %d\n", err);
 		return err;
 	}
 
 	err = hdmi_avi_infoframe_pack(&frame, buffer, sizeof(buffer));
 	if (err < 0) {
-		dev_err(sor->dev, "failed to pack AVI infoframe: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to pack AVI infoframe: %d\n", err);
 		return err;
 	}
 
@@ -1963,7 +1978,7 @@ static void tegra_sor_hdmi_disable(struct drm_encoder *encoder)
 
 	err = tegra_sor_detach(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to detach SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to detach SOR: %d\n", err);
 
 	tegra_sor_writel(sor, 0, SOR_STATE1);
 	tegra_sor_update(sor);
@@ -1978,11 +1993,12 @@ static void tegra_sor_hdmi_disable(struct drm_encoder *encoder)
 
 	err = tegra_sor_power_down(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power down SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to power down SOR: %d\n", err);
 
 	err = tegra_io_rail_power_off(TEGRA_IO_RAIL_HDMI);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power off HDMI rail: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to power off HDMI rail: %d\n", err);
 
 	pm_runtime_put(sor->dev);
 }
@@ -2008,13 +2024,15 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 	/* switch to safe parent clock */
 	err = tegra_sor_set_parent_clock(sor, sor->clk_safe);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set safe parent clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set safe parent clock: %d\n", err);
 
 	div = clk_get_rate(sor->clk) / 1000000 * 4;
 
 	err = tegra_io_rail_power_on(TEGRA_IO_RAIL_HDMI);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power on HDMI rail: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to power on HDMI rail: %d\n", err);
 
 	usleep_range(20, 100);
 
@@ -2113,11 +2131,13 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 	/* switch to parent clock */
 	err = clk_set_parent(sor->clk_src, sor->clk_parent);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set source clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set source clock: %d\n", err);
 
 	err = tegra_sor_set_parent_clock(sor, sor->clk_src);
 	if (err < 0)
-		dev_err(sor->dev, "failed to set parent clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to set parent clock: %d\n", err);
 
 	value = SOR_INPUT_CONTROL_HDMI_SRC_SELECT(dc->pipe);
 
@@ -2151,7 +2171,8 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 	/* infoframe setup */
 	err = tegra_sor_hdmi_setup_avi_infoframe(sor, mode);
 	if (err < 0)
-		dev_err(sor->dev, "failed to setup AVI infoframe: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to setup AVI infoframe: %d\n", err);
 
 	/* XXX HDMI audio support not implemented yet */
 	tegra_sor_hdmi_disable_audio_infoframe(sor);
@@ -2170,7 +2191,7 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 	/* production settings */
 	settings = tegra_sor_hdmi_find_settings(sor, mode->clock * 1000);
 	if (!settings) {
-		dev_err(sor->dev, "no settings for pixel clock %d Hz\n",
+		DRM_DEV_ERROR(sor->dev, "no settings for pixel clock %d Hz\n",
 			mode->clock * 1000);
 		return;
 	}
@@ -2244,7 +2265,7 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 
 	err = tegra_sor_power_up(sor, 250);
 	if (err < 0)
-		dev_err(sor->dev, "failed to power up SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to power up SOR: %d\n", err);
 
 	/* configure dynamic range of output */
 	value = tegra_sor_readl(sor, SOR_HEAD_STATE0(dc->pipe));
@@ -2264,7 +2285,7 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 
 	err = tegra_sor_attach(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to attach SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to attach SOR: %d\n", err);
 
 	/* enable display to SOR clock and generate HDMI preamble */
 	value = tegra_dc_readl(dc, DC_DISP_DISP_WIN_OPTIONS);
@@ -2275,7 +2296,7 @@ static void tegra_sor_hdmi_enable(struct drm_encoder *encoder)
 
 	err = tegra_sor_wakeup(sor);
 	if (err < 0)
-		dev_err(sor->dev, "failed to wakeup SOR: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to wakeup SOR: %d\n", err);
 }
 
 static const struct drm_encoder_helper_funcs tegra_sor_hdmi_helpers = {
@@ -2332,7 +2353,8 @@ static int tegra_sor_init(struct host1x_client *client)
 
 	err = tegra_output_init(drm, &sor->output);
 	if (err < 0) {
-		dev_err(client->dev, "failed to initialize output: %d\n", err);
+		DRM_DEV_ERROR(client->dev,
+			"failed to initialize output: %d\n", err);
 		return err;
 	}
 
@@ -2341,13 +2363,15 @@ static int tegra_sor_init(struct host1x_client *client)
 	if (IS_ENABLED(CONFIG_DEBUG_FS)) {
 		err = tegra_sor_debugfs_init(sor, drm->primary);
 		if (err < 0)
-			dev_err(sor->dev, "debugfs setup failed: %d\n", err);
+			DRM_DEV_ERROR(sor->dev,
+				"debugfs setup failed: %d\n", err);
 	}
 
 	if (sor->aux) {
 		err = drm_dp_aux_attach(sor->aux, &sor->output);
 		if (err < 0) {
-			dev_err(sor->dev, "failed to attach DP: %d\n", err);
+			DRM_DEV_ERROR(sor->dev,
+				"failed to attach DP: %d\n", err);
 			return err;
 		}
 	}
@@ -2359,7 +2383,8 @@ static int tegra_sor_init(struct host1x_client *client)
 	if (sor->rst) {
 		err = reset_control_assert(sor->rst);
 		if (err < 0) {
-			dev_err(sor->dev, "failed to assert SOR reset: %d\n",
+			DRM_DEV_ERROR(sor->dev,
+				"failed to assert SOR reset: %d\n",
 				err);
 			return err;
 		}
@@ -2367,7 +2392,7 @@ static int tegra_sor_init(struct host1x_client *client)
 
 	err = clk_prepare_enable(sor->clk);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to enable clock: %d\n", err);
+		DRM_DEV_ERROR(sor->dev, "failed to enable clock: %d\n", err);
 		return err;
 	}
 
@@ -2376,7 +2401,8 @@ static int tegra_sor_init(struct host1x_client *client)
 	if (sor->rst) {
 		err = reset_control_deassert(sor->rst);
 		if (err < 0) {
-			dev_err(sor->dev, "failed to deassert SOR reset: %d\n",
+			DRM_DEV_ERROR(sor->dev,
+				"failed to deassert SOR reset: %d\n",
 				err);
 			return err;
 		}
@@ -2403,7 +2429,8 @@ static int tegra_sor_exit(struct host1x_client *client)
 	if (sor->aux) {
 		err = drm_dp_aux_detach(sor->aux);
 		if (err < 0) {
-			dev_err(sor->dev, "failed to detach DP: %d\n", err);
+			DRM_DEV_ERROR(sor->dev,
+				"failed to detach DP: %d\n", err);
 			return err;
 		}
 	}
@@ -2433,42 +2460,44 @@ static int tegra_sor_hdmi_probe(struct tegra_sor *sor)
 
 	sor->avdd_io_supply = devm_regulator_get(sor->dev, "avdd-io");
 	if (IS_ERR(sor->avdd_io_supply)) {
-		dev_err(sor->dev, "cannot get AVDD I/O supply: %ld\n",
+		DRM_DEV_ERROR(sor->dev, "cannot get AVDD I/O supply: %ld\n",
 			PTR_ERR(sor->avdd_io_supply));
 		return PTR_ERR(sor->avdd_io_supply);
 	}
 
 	err = regulator_enable(sor->avdd_io_supply);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to enable AVDD I/O supply: %d\n",
+		DRM_DEV_ERROR(sor->dev,
+			"failed to enable AVDD I/O supply: %d\n",
 			err);
 		return err;
 	}
 
 	sor->vdd_pll_supply = devm_regulator_get(sor->dev, "vdd-pll");
 	if (IS_ERR(sor->vdd_pll_supply)) {
-		dev_err(sor->dev, "cannot get VDD PLL supply: %ld\n",
+		DRM_DEV_ERROR(sor->dev, "cannot get VDD PLL supply: %ld\n",
 			PTR_ERR(sor->vdd_pll_supply));
 		return PTR_ERR(sor->vdd_pll_supply);
 	}
 
 	err = regulator_enable(sor->vdd_pll_supply);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to enable VDD PLL supply: %d\n",
+		DRM_DEV_ERROR(sor->dev, "failed to enable VDD PLL supply: %d\n",
 			err);
 		return err;
 	}
 
 	sor->hdmi_supply = devm_regulator_get(sor->dev, "hdmi");
 	if (IS_ERR(sor->hdmi_supply)) {
-		dev_err(sor->dev, "cannot get HDMI supply: %ld\n",
+		DRM_DEV_ERROR(sor->dev, "cannot get HDMI supply: %ld\n",
 			PTR_ERR(sor->hdmi_supply));
 		return PTR_ERR(sor->hdmi_supply);
 	}
 
 	err = regulator_enable(sor->hdmi_supply);
 	if (err < 0) {
-		dev_err(sor->dev, "failed to enable HDMI supply: %d\n", err);
+		DRM_DEV_ERROR(sor->dev,
+			"failed to enable HDMI supply: %d\n", err);
 		return err;
 	}
 
@@ -2573,34 +2602,35 @@ static int tegra_sor_probe(struct platform_device *pdev)
 		if (sor->soc->supports_hdmi) {
 			sor->ops = &tegra_sor_hdmi_ops;
 		} else if (sor->soc->supports_lvds) {
-			dev_err(&pdev->dev, "LVDS not supported yet\n");
+			DRM_DEV_ERROR(&pdev->dev, "LVDS not supported yet\n");
 			return -ENODEV;
 		} else {
-			dev_err(&pdev->dev, "unknown (non-DP) support\n");
+			DRM_DEV_ERROR(&pdev->dev, "unknown (non-DP) support\n");
 			return -ENODEV;
 		}
 	} else {
 		if (sor->soc->supports_edp) {
 			sor->ops = &tegra_sor_edp_ops;
 		} else if (sor->soc->supports_dp) {
-			dev_err(&pdev->dev, "DisplayPort not supported yet\n");
+			DRM_DEV_ERROR(&pdev->dev,
+				"DisplayPort not supported yet\n");
 			return -ENODEV;
 		} else {
-			dev_err(&pdev->dev, "unknown (DP) support\n");
+			DRM_DEV_ERROR(&pdev->dev, "unknown (DP) support\n");
 			return -ENODEV;
 		}
 	}
 
 	err = tegra_output_probe(&sor->output);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to probe output: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev, "failed to probe output: %d\n", err);
 		return err;
 	}
 
 	if (sor->ops && sor->ops->probe) {
 		err = sor->ops->probe(sor);
 		if (err < 0) {
-			dev_err(&pdev->dev, "failed to probe %s: %d\n",
+			DRM_DEV_ERROR(&pdev->dev, "failed to probe %s: %d\n",
 				sor->ops->name, err);
 			goto output;
 		}
@@ -2617,7 +2647,8 @@ static int tegra_sor_probe(struct platform_device *pdev)
 		sor->rst = devm_reset_control_get(&pdev->dev, "sor");
 		if (IS_ERR(sor->rst)) {
 			err = PTR_ERR(sor->rst);
-			dev_err(&pdev->dev, "failed to get reset control: %d\n",
+			DRM_DEV_ERROR(&pdev->dev,
+				"failed to get reset control: %d\n",
 				err);
 			goto remove;
 		}
@@ -2626,7 +2657,8 @@ static int tegra_sor_probe(struct platform_device *pdev)
 	sor->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(sor->clk)) {
 		err = PTR_ERR(sor->clk);
-		dev_err(&pdev->dev, "failed to get module clock: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to get module clock: %d\n", err);
 		goto remove;
 	}
 
@@ -2634,7 +2666,8 @@ static int tegra_sor_probe(struct platform_device *pdev)
 		sor->clk_src = devm_clk_get(&pdev->dev, "source");
 		if (IS_ERR(sor->clk_src)) {
 			err = PTR_ERR(sor->clk_src);
-			dev_err(sor->dev, "failed to get source clock: %d\n",
+			DRM_DEV_ERROR(sor->dev,
+				"failed to get source clock: %d\n",
 				err);
 			goto remove;
 		}
@@ -2643,21 +2676,23 @@ static int tegra_sor_probe(struct platform_device *pdev)
 	sor->clk_parent = devm_clk_get(&pdev->dev, "parent");
 	if (IS_ERR(sor->clk_parent)) {
 		err = PTR_ERR(sor->clk_parent);
-		dev_err(&pdev->dev, "failed to get parent clock: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to get parent clock: %d\n", err);
 		goto remove;
 	}
 
 	sor->clk_safe = devm_clk_get(&pdev->dev, "safe");
 	if (IS_ERR(sor->clk_safe)) {
 		err = PTR_ERR(sor->clk_safe);
-		dev_err(&pdev->dev, "failed to get safe clock: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to get safe clock: %d\n", err);
 		goto remove;
 	}
 
 	sor->clk_dp = devm_clk_get(&pdev->dev, "dp");
 	if (IS_ERR(sor->clk_dp)) {
 		err = PTR_ERR(sor->clk_dp);
-		dev_err(&pdev->dev, "failed to get DP clock: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev, "failed to get DP clock: %d\n", err);
 		goto remove;
 	}
 
@@ -2670,7 +2705,8 @@ static int tegra_sor_probe(struct platform_device *pdev)
 
 	if (IS_ERR(sor->clk_brick)) {
 		err = PTR_ERR(sor->clk_brick);
-		dev_err(&pdev->dev, "failed to register SOR clock: %d\n", err);
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register SOR clock: %d\n", err);
 		goto remove;
 	}
 
@@ -2680,7 +2716,8 @@ static int tegra_sor_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&sor->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to register host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to register host1x client: %d\n",
 			err);
 		goto remove;
 	}
@@ -2704,7 +2741,8 @@ static int tegra_sor_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&sor->client);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
@@ -2712,7 +2750,8 @@ static int tegra_sor_remove(struct platform_device *pdev)
 	if (sor->ops && sor->ops->remove) {
 		err = sor->ops->remove(sor);
 		if (err < 0)
-			dev_err(&pdev->dev, "failed to remove SOR: %d\n", err);
+			DRM_DEV_ERROR(&pdev->dev,
+				"failed to remove SOR: %d\n", err);
 	}
 
 	tegra_output_remove(&sor->output);
@@ -2729,7 +2768,7 @@ static int tegra_sor_suspend(struct device *dev)
 	if (sor->rst) {
 		err = reset_control_assert(sor->rst);
 		if (err < 0) {
-			dev_err(dev, "failed to assert reset: %d\n", err);
+			DRM_DEV_ERROR(dev, "failed to assert reset: %d\n", err);
 			return err;
 		}
 	}
@@ -2748,7 +2787,7 @@ static int tegra_sor_resume(struct device *dev)
 
 	err = clk_prepare_enable(sor->clk);
 	if (err < 0) {
-		dev_err(dev, "failed to enable clock: %d\n", err);
+		DRM_DEV_ERROR(dev, "failed to enable clock: %d\n", err);
 		return err;
 	}
 
@@ -2757,7 +2796,8 @@ static int tegra_sor_resume(struct device *dev)
 	if (sor->rst) {
 		err = reset_control_deassert(sor->rst);
 		if (err < 0) {
-			dev_err(dev, "failed to deassert reset: %d\n", err);
+			DRM_DEV_ERROR(dev,
+				"failed to deassert reset: %d\n", err);
 			clk_disable_unprepare(sor->clk);
 			return err;
 		}
diff --git a/drivers/gpu/drm/tegra/vic.c b/drivers/gpu/drm/tegra/vic.c
index 2448229..cb85541 100644
--- a/drivers/gpu/drm/tegra/vic.c
+++ b/drivers/gpu/drm/tegra/vic.c
@@ -104,7 +104,7 @@ static int vic_boot(struct vic *vic)
 
 	err = falcon_wait_idle(&vic->falcon);
 	if (err < 0) {
-		dev_err(vic->dev,
+		DRM_DEV_ERROR(vic->dev,
 			"failed to set application ID and FCE base\n");
 		return err;
 	}
@@ -146,7 +146,8 @@ static int vic_init(struct host1x_client *client)
 	if (tegra->domain) {
 		err = iommu_attach_device(tegra->domain, vic->dev);
 		if (err < 0) {
-			dev_err(vic->dev, "failed to attach to domain: %d\n",
+			DRM_DEV_ERROR(vic->dev,
+				"failed to attach to domain: %d\n",
 				err);
 			return err;
 		}
@@ -299,7 +300,7 @@ static int vic_probe(struct platform_device *pdev)
 
 	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!regs) {
-		dev_err(&pdev->dev, "failed to get registers\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get registers\n");
 		return -ENXIO;
 	}
 
@@ -309,7 +310,7 @@ static int vic_probe(struct platform_device *pdev)
 
 	vic->clk = devm_clk_get(dev, NULL);
 	if (IS_ERR(vic->clk)) {
-		dev_err(&pdev->dev, "failed to get clock\n");
+		DRM_DEV_ERROR(&pdev->dev, "failed to get clock\n");
 		return PTR_ERR(vic->clk);
 	}
 
@@ -341,7 +342,8 @@ static int vic_probe(struct platform_device *pdev)
 
 	err = host1x_client_register(&vic->client.base);
 	if (err < 0) {
-		dev_err(dev, "failed to register host1x client: %d\n", err);
+		DRM_DEV_ERROR(dev,
+			"failed to register host1x client: %d\n", err);
 		platform_set_drvdata(pdev, NULL);
 		goto exit_falcon;
 	}
@@ -370,7 +372,8 @@ static int vic_remove(struct platform_device *pdev)
 
 	err = host1x_client_unregister(&vic->client.base);
 	if (err < 0) {
-		dev_err(&pdev->dev, "failed to unregister host1x client: %d\n",
+		DRM_DEV_ERROR(&pdev->dev,
+			"failed to unregister host1x client: %d\n",
 			err);
 		return err;
 	}
