media/hevc_d: Add runtime and system suspend/resume PM support

Replace the manual clock enable/disable on stream start/stop with
runtime PM, and add system sleep callbacks.

The IRQ enables in the interrupt controller were only set at probe.
Move them into the power on path so they are restored on every
resume.

On system suspend, stop new m2m jobs being run and then sync with
the IRQ machinery. v4l2_m2m_suspend() only waits for the current
job to finish, but jobs are finished before the h/w has completed
phase 1 and phase 2, so that alone does not leave the h/w idle.

Signed-off-by: John Cox <jc@kynesim.co.uk>

Author: jc-kynesim

drivers/media/platform/raspberrypi/hevc_dec/hevc_d.c

@@ -13,6 +13,7 @@
 
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 #include <linux/module.h>
 
 #include <media/v4l2-device.h>
@@ -220,6 +221,8 @@ static int hevc_d_probe(struct platform_device *pdev)
 	dev->vfd = hevc_d_video_device;
 	dev->dev = &pdev->dev;
 	dev->pdev = pdev;
+	/* Must be set before runtime PM is enabled in hevc_d_hw_probe */
+	platform_set_drvdata(pdev, dev);
 
 	ret = hevc_d_hw_probe(dev);
 	if (ret) {
@@ -290,8 +293,6 @@ static int hevc_d_probe(struct platform_device *pdev)
 		goto err_m2m_mc;
 	}
 
-	platform_set_drvdata(pdev, dev);
-
 	return 0;
 
 err_m2m_mc:
@@ -326,6 +327,59 @@ static void hevc_d_remove(struct platform_device *pdev)
 	hevc_d_hw_remove(dev);
 }
 
+static int hevc_d_runtime_suspend(struct device *d)
+{
+	struct hevc_d_dev *dev = dev_get_drvdata(d);
+
+	hevc_d_hw_power_off(dev);
+	return 0;
+}
+
+static int hevc_d_runtime_resume(struct device *d)
+{
+	struct hevc_d_dev *dev = dev_get_drvdata(d);
+
+	return hevc_d_hw_power_on(dev);
+}
+
+static int hevc_d_suspend(struct device *d)
+{
+	struct hevc_d_dev *dev = dev_get_drvdata(d);
+	int ret;
+
+	/* Stop new jobs being started */
+	v4l2_m2m_suspend(dev->m2m_dev);
+	/*
+	 * v4l2_m2m_suspend only waits for the current job to finish but we
+	 * finish jobs before the h/w is done with them so also wait for any
+	 * phase 1 / phase 2 work still in flight
+	 */
+	hevc_d_h265_sync(dev);
+
+	ret = pm_runtime_force_suspend(d);
+	if (ret)
+		v4l2_m2m_resume(dev->m2m_dev);
+	return ret;
+}
+
+static int hevc_d_resume(struct device *d)
+{
+	struct hevc_d_dev *dev = dev_get_drvdata(d);
+	int ret;
+
+	ret = pm_runtime_force_resume(d);
+	if (ret)
+		return ret;
+
+	v4l2_m2m_resume(dev->m2m_dev);
+	return 0;
+}
+
+static const struct dev_pm_ops hevc_d_pm_ops = {
+	SYSTEM_SLEEP_PM_OPS(hevc_d_suspend, hevc_d_resume)
+	RUNTIME_PM_OPS(hevc_d_runtime_suspend, hevc_d_runtime_resume, NULL)
+};
+
 static const struct of_device_id hevc_d_dt_match[] = {
 	{ .compatible = "brcm,bcm2711-hevc-dec", },
 	{ .compatible = "brcm,bcm2712-hevc-dec", },
@@ -339,6 +393,7 @@ static struct platform_driver hevc_d_driver = {
 	.driver		= {
 		.name = HEVC_D_NAME,
 		.of_match_table	= hevc_d_dt_match,
+		.pm = pm_ptr(&hevc_d_pm_ops),
 	},
 };
 module_platform_driver(hevc_d_driver);

drivers/media/platform/raspberrypi/hevc_dec/hevc_d_h265.c

@@ -2318,6 +2318,12 @@ static void h265_ctx_uninit(struct hevc_d_dev *const dev, struct hevc_d_ctx *ctx
 	ctx->coeff_size_max = 0;
 }
 
+/* Wait for all queued h/w operations on all contexts to complete */
+void hevc_d_h265_sync(struct hevc_d_dev *dev)
+{
+	irq_sync(dev);
+}
+
 void hevc_d_h265_stop(struct hevc_d_ctx *ctx)
 {
 	struct hevc_d_dev *const dev = ctx->dev;

drivers/media/platform/raspberrypi/hevc_dec/hevc_d_h265.h

@@ -17,6 +17,7 @@ extern const struct v4l2_ctrl_ops hevc_d_hevc_slice_params_ctrl_ops;
 int hevc_d_h265_start(struct hevc_d_ctx *ctx);
 void hevc_d_h265_stop(struct hevc_d_ctx *ctx);
 void hevc_d_h265_trigger(struct hevc_d_ctx *ctx);
+void hevc_d_h265_sync(struct hevc_d_dev *dev);
 
 void hevc_d_device_run(void *priv);
 

drivers/media/platform/raspberrypi/hevc_dec/hevc_d_hw.c

@@ -13,6 +13,7 @@
 #include <linux/clk.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
+#include <linux/pm_runtime.h>
 
 #include <media/videobuf2-core.h>
 #include <media/v4l2-mem2mem.h>
@@ -300,20 +301,26 @@ void hevc_d_hw_irq_active2_irq(struct hevc_d_dev *dev,
 }
 
 /*
- * Stop the clock for this context
- * clk_disable_unprepare does ref counting so this will not actually
- * disable the clock if there are other running contexts
+ * Power down the h/w
+ * Called from runtime suspend (or directly if runtime PM is unavailable)
  */
-void hevc_d_hw_stop_clock(struct hevc_d_dev *dev)
+void hevc_d_hw_power_off(struct hevc_d_dev *dev)
 {
+	dev_dbg(dev->dev, "Power (clock) off\n");
 	clk_disable_unprepare(dev->clock);
 }
 
-/* Always starts the clock if it isn't already on this ctx */
-int hevc_d_hw_start_clock(struct hevc_d_dev *dev)
+/*
+ * Power up the h/w and (re)initialise any state that is not set per-job
+ * Called from runtime resume (or directly if runtime PM is unavailable)
+ */
+int hevc_d_hw_power_on(struct hevc_d_dev *dev)
 {
+	u32 irq_stat;
 	int rv;
 
+	dev_dbg(dev->dev, "Power (clock) on\n");
+
 	rv = clk_set_min_rate(dev->clock, dev->max_clock_rate);
 	if (rv) {
 		dev_err(dev->dev, "Failed to set clock rate\n");
@@ -325,22 +332,47 @@ int hevc_d_hw_start_clock(struct hevc_d_dev *dev)
 		dev_err(dev->dev, "Failed to enable clock\n");
 		return rv;
 	}
+
+	/*
+	 * Enable IRQs & reset anything pending
+	 * Whilst this seems the wrong way round the h/w doesn't actually
+	 * set the IRQ status bits till the IRQs are enabled. On probe we
+	 * haven't got the IRQ yet and on resume nothing is in flight so
+	 * this should still be safe.
+	 */
+	irq_write(dev, ARG_IC_ICTRL,
+		  ARG_IC_ICTRL_ACTIVE1_EN_SET | ARG_IC_ICTRL_ACTIVE2_EN_SET);
+	irq_stat = irq_read(dev, ARG_IC_ICTRL);
+	irq_write(dev, ARG_IC_ICTRL, irq_stat);
+
 	return 0;
 }
 
-static int hw_setup(struct hevc_d_dev *dev)
+/*
+ * Take a power reference for this context
+ * Runtime PM does ref counting so the h/w stays powered whilst any
+ * context holds a reference
+ */
+int hevc_d_hw_pm_get(struct hevc_d_dev *dev)
+{
+	int rv;
+
+	rv = pm_runtime_resume_and_get(dev->dev);
+	if (rv)
+		dev_err(dev->dev, "Failed to power up: %d\n", rv);
+	return rv;
+}
+
+void hevc_d_hw_pm_put(struct hevc_d_dev *dev)
+{
+	pm_runtime_put(dev->dev);
+}
+
+static int get_max_clock_rate(struct hevc_d_dev *dev)
 {
 	struct device_node *node;
-	u32 ver;
-	u32 irq_stat;
 	struct rpi_firmware *firmware;
 
-	ver = apb_read(dev, RPI_VERSION);
-	if (ver != 0x202) {
-		dev_err(dev->dev, "Unexpected version %#x only 0x202 supported\n", ver);
-		return -ENODEV;
-	}
-
 	node = rpi_firmware_find_node();
 	if (!node)
 		return -EINVAL;
@@ -354,17 +386,19 @@ static int hw_setup(struct hevc_d_dev *dev)
 							    RPI_FIRMWARE_HEVC_CLK_ID);
 	rpi_firmware_put(firmware);
 
-	/*
-	 * Enable IRQs & reset anything pending
-	 * Whilst this seems the wrong way round the h/w doesn't actually
-	 * set the IRQ status bits till the IRQs are enabled. As we haven't
-	 * got the IRQ yet this should still be safe.
-	 */
-	irq_write(dev, ARG_IC_ICTRL,
-		  ARG_IC_ICTRL_ACTIVE1_EN_SET | ARG_IC_ICTRL_ACTIVE2_EN_SET);
-	irq_stat = irq_read(dev, ARG_IC_ICTRL);
-	irq_write(dev, ARG_IC_ICTRL, irq_stat);
+	return 0;
+}
+
+/* H/w must be powered */
+static int check_version(struct hevc_d_dev *dev)
+{
+	u32 ver;
 
+	ver = apb_read(dev, RPI_VERSION);
+	if (ver != 0x202) {
+		dev_err(dev->dev, "Unexpected version %#x only 0x202 supported\n", ver);
+		return -ENODEV;
+	}
 	return 0;
 }
 
@@ -388,34 +422,58 @@ int hevc_d_hw_probe(struct hevc_d_dev *dev)
 	if (IS_ERR(dev->clock))
 		return PTR_ERR(dev->clock);
 
-	ret = clk_prepare_enable(dev->clock);
+	ret = get_max_clock_rate(dev);
 	if (ret)
 		return ret;
-	ret = hw_setup(dev);
-	clk_disable_unprepare(dev->clock);
+
+	/*
+	 * Power up manually so this works without runtime PM. Runtime PM is
+	 * told we are active once enabled and the driver core idles us after
+	 * probe completes.
+	 */
+	ret = hevc_d_hw_power_on(dev);
 	if (ret)
 		return ret;
 
+	ret = check_version(dev);
+	if (ret)
+		goto fail_power_off;
+
 	irq_dec = platform_get_irq(dev->pdev, 0);
-	if (irq_dec < 0)
-		return irq_dec;
+	if (irq_dec < 0) {
+		ret = irq_dec;
+		goto fail_power_off;
+	}
 	ret = devm_request_threaded_irq(dev->dev, irq_dec,
 					hevc_d_irq_irq,
 					hevc_d_irq_thread,
 					0, dev_name(dev->dev), dev);
-	if (ret)
+	if (ret) {
 		dev_err(dev->dev, "Failed to request IRQ - %d\n", ret);
+		goto fail_power_off;
+	}
+
+	pm_runtime_set_active(dev->dev);
+	pm_runtime_enable(dev->dev);
 
+	return 0;
+
+fail_power_off:
+	hevc_d_hw_power_off(dev);
 	return ret;
 }
 
 void hevc_d_hw_remove(struct hevc_d_dev *dev)
 {
+	pm_runtime_disable(dev->dev);
+	if (!pm_runtime_status_suspended(dev->dev))
+		hevc_d_hw_power_off(dev);
+	pm_runtime_set_suspended(dev->dev);
+
 	/*
 	 * IRQ auto freed on unload so no need to do it here
 	 * ioremap auto freed on unload
 	 */
 	ictl_uninit(&dev->ic_active1);
 	ictl_uninit(&dev->ic_active2);
 }
-

drivers/media/platform/raspberrypi/hevc_dec/hevc_d_hw.h

@@ -312,8 +312,10 @@ void hevc_d_hw_irq_active2_irq(struct hevc_d_dev *dev,
 			       struct hevc_d_hw_irq_ent *ient,
 			       hevc_d_irq_callback irq_cb, void *ctx);
 
-int hevc_d_hw_start_clock(struct hevc_d_dev *dev);
-void hevc_d_hw_stop_clock(struct hevc_d_dev *dev);
+int hevc_d_hw_power_on(struct hevc_d_dev *dev);
+void hevc_d_hw_power_off(struct hevc_d_dev *dev);
+int hevc_d_hw_pm_get(struct hevc_d_dev *dev);
+void hevc_d_hw_pm_put(struct hevc_d_dev *dev);
 
 int hevc_d_hw_probe(struct hevc_d_dev *dev);
 void hevc_d_hw_remove(struct hevc_d_dev *dev);

drivers/media/platform/raspberrypi/hevc_dec/hevc_d_video.c

@@ -535,19 +535,19 @@ static int hevc_d_start_streaming(struct vb2_queue *vq, unsigned int count)
 	v4l2_m2m_update_start_streaming_state(ctx->fh.m2m_ctx, vq);
 
 	if (V4L2_TYPE_IS_OUTPUT(vq->type)) {
-		ret = hevc_d_hw_start_clock(dev);
+		ret = hevc_d_hw_pm_get(dev);
 		if (ret)
 			goto fail_cleanup;
 
 		ret = hevc_d_h265_start(ctx);
 		if (ret)
-			goto fail_stop_clock;
+			goto fail_pm_put;
 	}
 
 	return 0;
 
-fail_stop_clock:
-	hevc_d_hw_stop_clock(dev);
+fail_pm_put:
+	hevc_d_hw_pm_put(dev);
 fail_cleanup:
 	v4l2_err(&dev->v4l2_dev, "%s: qtype=%d: FAIL\n", __func__, vq->type);
 	hevc_d_queue_cleanup(vq, VB2_BUF_STATE_QUEUED);
@@ -561,7 +561,7 @@ static void hevc_d_stop_streaming(struct vb2_queue *vq)
 
 	if (V4L2_TYPE_IS_OUTPUT(vq->type)) {
 		hevc_d_h265_stop(ctx);
-		hevc_d_hw_stop_clock(dev);
+		hevc_d_hw_pm_put(dev);
 	}
 
 	hevc_d_queue_cleanup(vq, VB2_BUF_STATE_ERROR);