drm/apple: Support DCP shutdown and restart

Required to support module unload / reload.

This doesn't quite look like it was intended to be used this way but it
works out.
For now this is handled as developer feature and taint the kernel on
DCP resets.

Main area of concern is the lack of reset of the DCP co-processor.
It only works if it was correctly shutdown. DCP keeps state after
shutdown and "reset". The shared memory DVA used for iomfb message
passing is retained. It is possible to reset it but DCP does not react
in the same way requiring a different init sequence. It's conceiveable
that other state is retained as well causing subtle problems.

Signed-off-by: Janne Grunau <[email protected]>

Author: jannau

drivers/gpu/drm/apple/apple_drv.c

@@ -406,6 +406,8 @@ static int apple_drm_init_dcp(struct device *dev)
 	int i, ret, num_dcp = 0;
 
 	for_each_matching_node(np, apple_dcp_id_tbl) {
+		struct device_link *link;
+
 		if (!of_device_is_available(np)) {
 			of_node_put(np);
 			continue;
@@ -415,6 +417,13 @@ static int apple_drm_init_dcp(struct device *dev)
 		of_node_put(np);
 		if (!dcp[num_dcp])
 			continue;
+	
+		link = device_link_add(dev, &dcp[num_dcp]->dev,
+			     DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER);
+
+		if (IS_ERR(link))
+			dev_warn(dev, "dcp[%d] device link failed:%d\n",
+				 num_dcp, PTR_ERR(link));
 
 		ret = apple_probe_per_dcp(dev, &apple->drm, dcp[num_dcp],
 					  num_dcp);

drivers/gpu/drm/apple/dcp-internal.h

@@ -8,6 +8,7 @@
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/platform_device.h>
+#include <linux/reset.h>
 #include <linux/scatterlist.h>
 
 #include "iomfb.h"
@@ -87,6 +88,7 @@ struct apple_dcp {
 	struct apple_rtkit *rtk;
 	struct apple_crtc *crtc;
 	struct apple_connector *connector;
+	struct reset_control *reset;
 
 	/* firmware version and compatible firmware version */
 	enum dcp_firmware_version fw_compat;
@@ -110,6 +112,7 @@ struct apple_dcp {
 
 	/* DCP shared memory */
 	void *shmem;
+	dma_addr_t shmem_iova;
 
 	/* Display registers mappable to the DCP */
 	struct resource *disp_registers[MAX_DISP_REGISTERS];
@@ -146,6 +149,9 @@ struct apple_dcp {
 	/* Is the DCP awake? */
 	bool awake;
 
+	/* Is the DCP shutting down? */
+	bool shutdown;
+
 	/* Is the DCP in the process of going to sleep? */
 	bool sleeping;
 

drivers/gpu/drm/apple/dcp.c

@@ -14,6 +14,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/of_device.h>
+#include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/soc/apple/rtkit.h>
 #include <linux/string.h>
@@ -422,7 +423,11 @@ static int dcp_comp_bind(struct device *dev, struct device *main, void *data)
 	if (IS_ERR(dcp->coproc_reg))
 		return PTR_ERR(dcp->coproc_reg);
 
-	of_platform_default_populate(dev->of_node, NULL, dev);
+	dcp->reset = devm_reset_control_array_get_exclusive(dev);
+	if (IS_ERR(dcp->reset)) {
+		return dev_err_probe(dev, PTR_ERR(dcp->reset),
+				     "Failed to get reset control");
+	}
 
 	if (!show_notch)
 		ret = of_property_read_u32(dev->of_node, "apple,notch-height",
@@ -509,13 +514,19 @@ static int dcp_comp_bind(struct device *dev, struct device *main, void *data)
 		return dev_err_probe(dev, PTR_ERR(dcp->rtk),
 				     "Failed to intialize RTKit");
 
-	ret = devm_pm_runtime_enable(dev);
+	/* calling pm_runtime_force_resume() is equivalent to pm_runtime_enable
+	 * if pm_runtime_force_suspend was not previously called
+	 */
+	ret = pm_runtime_force_resume(dev);
 	if (ret)
-		return ret;
+		dev_err_probe(dev, ret, "pm_runtime_force_resume failed!\n");
 
 	ret = pm_runtime_resume_and_get(dev);
-	if (ret)
-		return ret;
+	if (ret) {
+		devm_apple_rtkit_free(dev, dcp->rtk);
+		dcp->rtk = NULL;
+		return dev_err_probe(dev, ret, "pm_runtime_resume_and_get failed!\n");
+	}
 
 	pm_runtime_set_autosuspend_delay(dev, 50);
 	pm_runtime_use_autosuspend(dev);
@@ -542,15 +553,37 @@ static int dcp_comp_bind(struct device *dev, struct device *main, void *data)
 static void dcp_comp_unbind(struct device *dev, struct device *main, void *data)
 {
 	struct apple_dcp *dcp = dev_get_drvdata(dev);
+	int ret;
+
+	/*
+	 * Get device but limit resume to RTKit
+	 */
+	dcp->iomfb_started = false;
+	ret = pm_runtime_resume_and_get(dev);
+	if (ret)
+		dev_err(dev, "pm_runtime_resume_and_get failed: %d\n", ret);
+	pm_runtime_dont_use_autosuspend(dev);
+
+	/*
+	 * force_suspend and shutdown RTKit
+	 */
+	dcp->active = true;
+	dcp->shutdown = true;
+
+	ret = pm_runtime_force_suspend(dev);
+	if (ret)
+		dev_err(dev, "pm_runtime_put_sync_suspend failed: %d\n", ret);
 
-	if (dcp && dcp->shmem)
-		iomfb_shutdown(dcp);
+	dcp->rtk = NULL;
+
+	dcp->shutdown = false;
+	dcp->active = false;
 
 	platform_device_put(dcp->piodma);
 	dcp->piodma = NULL;
-
-	devm_clk_put(dev, dcp->clk);
 	dcp->clk = NULL;
+	dcp->coproc_reg = NULL;
+	iomfb_stop_rtkit(dcp);
 }
 
 static const struct component_ops dcp_comp_ops = {
@@ -563,11 +596,16 @@ static int dcp_platform_probe(struct platform_device *pdev)
 	enum dcp_firmware_version fw_compat;
 	struct device *dev = &pdev->dev;
 	struct apple_dcp *dcp;
+	int ret;
 
 	fw_compat = dcp_check_firmware_version(dev);
 	if (fw_compat == DCP_FIRMWARE_UNKNOWN)
 		return -ENODEV;
 
+	ret = devm_pm_runtime_enable(dev);
+	if (ret)
+		return ret;
+
 	dcp = devm_kzalloc(dev, sizeof(*dcp), GFP_KERNEL);
 	if (!dcp)
 		return -ENOMEM;
@@ -577,6 +615,11 @@ static int dcp_platform_probe(struct platform_device *pdev)
 
 	platform_set_drvdata(pdev, dcp);
 
+	/* force suspend for symmetry with dcp_comp_unbind */
+	ret = pm_runtime_force_suspend(dev);
+	if (ret)
+		dev_err(dev, "pm_runtime_put_sync_suspend failed: %d\n", ret);
+
 	return component_add(&pdev->dev, &dcp_comp_ops);
 }
 
@@ -598,9 +641,15 @@ static int __maybe_unused dcp_runtime_suspend(struct device *dev)
 	u32 cpu_ctrl;
 	int ret;
 
+	if (!dcp->rtk || !dcp->coproc_reg)
+		return 0;
+
 	dcp_sleep(dcp);
 
-	ret = apple_rtkit_idle(dcp->rtk);
+	if (dcp->shutdown)
+		ret = apple_rtkit_shutdown(dcp->rtk);
+	else
+		ret = apple_rtkit_idle(dcp->rtk);
 	if (ret) {
 		dev_err(dev, "Failed to shut down RTKit: %d", ret);
 		return ret;
@@ -622,12 +671,29 @@ static int __maybe_unused dcp_runtime_resume(struct device *dev)
 	u32 cpu_ctrl;
 	int ret;
 
+	if (!dcp->rtk || !dcp->coproc_reg)
+		return -ENODEV;
+
 	cpu_ctrl =
 		readl_relaxed(dcp->coproc_reg + APPLE_DCP_COPROC_CPU_CONTROL);
 	writel_relaxed(cpu_ctrl | APPLE_DCP_COPROC_CPU_CONTROL_RUN,
 		       dcp->coproc_reg + APPLE_DCP_COPROC_CPU_CONTROL);
 
 	ret = apple_rtkit_wake(dcp->rtk);
+	if (ret == -ETIME) {
+		dev_err(dev, "RTKit wakeup timed out, trying reset. Please do not report bugs");
+		add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_STILL_OK);
+
+		ret = reset_control_assert(dcp->reset);
+		if (ret)
+			dev_warn(dev, "reset_control_assert failed: %d\n", ret);
+
+		ret = reset_control_deassert(dcp->reset);
+		if (ret)
+			dev_warn(dev, "reset_control_deassert failed: %d\n", ret);
+
+		ret = apple_rtkit_wake(dcp->rtk);
+	}
 	if (ret) {
 		dev_err(dev, "Failed to wake up RTKit: %d", ret);
 		return ret;
@@ -651,9 +717,7 @@ static const struct of_device_id of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, of_match);
 
-static const struct dev_pm_ops dcp_pm_ops = {
-        SET_RUNTIME_PM_OPS(dcp_runtime_suspend, dcp_runtime_resume, NULL)
-};
+DEFINE_RUNTIME_DEV_PM_OPS(dcp_pm_ops, dcp_runtime_suspend, dcp_runtime_resume, NULL);
 
 static struct platform_driver dcp_driver = {
 	.probe		= dcp_platform_probe,

drivers/gpu/drm/apple/dcp.h

@@ -64,7 +64,7 @@ void dcp_set_dimensions(struct apple_dcp *dcp);
 void dcp_send_message(struct apple_dcp *dcp, u8 endpoint, u64 message);
 
 int iomfb_start_rtkit(struct apple_dcp *dcp);
-void iomfb_shutdown(struct apple_dcp *dcp);
+void iomfb_stop_rtkit(struct apple_dcp *dcp);
 /* rtkit message handler for IOMFB messages */
 void iomfb_recv_msg(struct apple_dcp *dcp, u64 message);
 

drivers/gpu/drm/apple/iomfb.c

@@ -1972,45 +1972,68 @@ static void dcp_started(struct apple_dcp *dcp, void *data, void *cookie)
 	iomfb_get_color_remap_mode(dcp, false, &color_remap, init_1, cookie);
 }
 
+static void dcp_shmem_info(struct apple_dcp *dcp, u64 dcp_dva)
+{
+	dma_addr_t shmem_iova;
+
+	if (dcp_dva != 0 && dcp->shmem_iova == (dcp_dva & ~dcp->asc_dram_mask))
+		return;
+
+	dcp->shmem = dma_alloc_coherent(dcp->dev, DCP_SHMEM_SIZE,
+					&dcp->shmem_iova, GFP_KERNEL);
+
+	shmem_iova = dcp->shmem_iova | dcp->asc_dram_mask;
+	dcp_send_message(dcp, IOMFB_ENDPOINT, dcpep_set_shmem(shmem_iova));
+
+	if (dcp_dva != 0)
+		dcp_send_message(dcp, IOMFB_ENDPOINT,
+				 FIELD_PREP(IOMFB_MESSAGE_TYPE,
+					    IOMFB_MESSAGE_TYPE_INITIALIZED));
+}
+
 void iomfb_recv_msg(struct apple_dcp *dcp, u64 message)
 {
 	enum dcpep_type type = FIELD_GET(IOMFB_MESSAGE_TYPE, message);
 
-	if (type == IOMFB_MESSAGE_TYPE_INITIALIZED)
+	switch (type) {
+	case IOMFB_MESSAGE_TYPE_SET_SHMEM:
+		dcp_shmem_info(dcp, FIELD_GET(IOMFB_SHMEM_DVA, message));
+		break;
+	case IOMFB_MESSAGE_TYPE_INITIALIZED:
 		dcp_start_signal(dcp, false, dcp_started, NULL);
-	else if (type == IOMFB_MESSAGE_TYPE_MSG)
+		break;
+	case IOMFB_MESSAGE_TYPE_MSG:
 		dcpep_got_msg(dcp, message);
-	else
-		dev_warn(dcp->dev, "Ignoring unknown message %llx\n", message);
+		break;
+	default:
+		dev_warn(dcp->dev, "Ignoring unknown type:%x msg:%llx\n", type,
+			 message);
+		break;
+	}
 }
 
 int iomfb_start_rtkit(struct apple_dcp *dcp)
 {
-	dma_addr_t shmem_iova;
 	int ret;
 
 	ret = apple_rtkit_start_ep(dcp->rtk, IOMFB_ENDPOINT);
 	if (ret < 0)
 		return ret;
 
-	dcp->shmem = dma_alloc_coherent(dcp->dev, DCP_SHMEM_SIZE, &shmem_iova,
-					GFP_KERNEL);
-
-	shmem_iova |= dcp->asc_dram_mask;
-	dcp_send_message(dcp, IOMFB_ENDPOINT, dcpep_set_shmem(shmem_iova));
+	/*
+	* Query current shared memory IOVA used for iomfb message passing
+	*/
+	dcp_send_message(dcp, IOMFB_ENDPOINT,
+				FIELD_PREP(IOMFB_MESSAGE_TYPE, IOMFB_MESSAGE_TYPE_SET_SHMEM) |
+				FIELD_PREP(IOMFB_SHMEM_FLAG, 0)
+	);
 
 	return 0;
 }
 
-void iomfb_shutdown(struct apple_dcp *dcp)
+void iomfb_stop_rtkit(struct apple_dcp *dcp)
 {
-	struct dcp_set_power_state_req req = {
-		/* defaults are ok */
-	};
-
-	/* We're going down */
-	dcp->active = false;
-	dcp->valid_mode = false;
-
-	dcp_set_power_state(dcp, false, &req, NULL, NULL);
+	dma_free_coherent(dcp->dev, DCP_SHMEM_SIZE, dcp->shmem, dcp->shmem_iova);
+	dcp->shmem = NULL;
+	dcp->shmem_iova = 0;
 }