media: rockchip: rkcif: recover from a lost MIPI line

index bc9518f8db507..686b995525b9b 100644
@@ -810,6 +810,23 @@ static void rkcif_mipi_set_crop(struct rkcif_stream *stream, u16 left, u16 top)
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_CROP_START, val);
 }
 
+void rkcif_mipi_irq_mask(struct rkcif_device *rkcif)
+{
+	if (!rkcif->match_data->mipi)
+		return;
+
+	for (unsigned int i = 0; i < rkcif->match_data->mipi->mipi_num; i++) {
+		struct rkcif_interface *interface =
+			&rkcif->interfaces[RKCIF_MIPI_BASE + i];
+
+		if (!interface->rkcif)
+			continue;
+
+		rkcif_mipi_write(interface, RKCIF_MIPI_INTEN, 0);
+		rkcif_mipi_write(interface, RKCIF_MIPI_INTSTAT, ~0);
+	}
+}
+
 irqreturn_t rkcif_mipi_isr(int irq, void *ctx)
 {
 	struct device *dev = ctx;

@@ -823,6 +840,8 @@ irqreturn_t rkcif_mipi_isr(int irq, void *ctx)
 
 		intstat = rkcif_mipi_read(interface, RKCIF_MIPI_INTSTAT);
 		rkcif_mipi_write(interface, RKCIF_MIPI_INTSTAT, intstat);
+		if (intstat)
+			ret = IRQ_HANDLED;
 
 		for (unsigned int j = 0; j < interface->streams_num; j++) {
 			struct rkcif_stream *stream = &interface->streams[j];

index 7edaca44f653c..167b43756929b 100644
@@ -21,4 +21,6 @@ void rkcif_mipi_unregister(struct rkcif_device *rkcif);
 
 irqreturn_t rkcif_mipi_isr(int irq, void *ctx);
 
+void rkcif_mipi_irq_mask(struct rkcif_device *rkcif);
+
 #endif

index be3a174b9aab0..fbc8ed78d99ea 100644
@@ -281,6 +281,7 @@ static int rkcif_runtime_suspend(struct device *dev)
 	reset_control_assert(rkcif->reset);
 	udelay(5);
 	reset_control_deassert(rkcif->reset);
+	rkcif_mipi_irq_mask(rkcif);
 
 	clk_bulk_disable_unprepare(rkcif->clks_num, rkcif->clks);
 

@@ -298,6 +299,8 @@ static int rkcif_runtime_resume(struct device *dev)
 		return ret;
 	}
 
+	rkcif_mipi_irq_mask(rkcif);
+
 	return 0;
 }
 

index 686b995525b9b..53cfd37bf02bd 100644
@@ -721,17 +721,14 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 	struct rkcif_interface *interface = stream->interface;
 	const struct rkcif_output_fmt *active_out_fmt;
 	const struct rkcif_mipi_match_data *match_data;
-	struct v4l2_subdev_state *state;
 	u32 ctrl0 = 0, ctrl1 = 0, int_temp = 0, int_mask = 0, vlw = 0;
+	unsigned long flags;
 	u16 height, width;
-	int ret = -EINVAL;
-
-	state = v4l2_subdev_lock_and_get_active_state(&interface->sd);
 
 	active_out_fmt = rkcif_stream_find_output_fmt(stream, false,
 						      stream->pix.pixelformat);
 	if (!active_out_fmt)
-		goto out;
+		return -EINVAL;
 
 	height = stream->pix.height;
 	width = stream->pix.width;

@@ -746,6 +743,7 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 	int_mask |= RKCIF_MIPI_INT_FRAME0_END(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME1_END(stream->id);
 
+	spin_lock_irqsave(&interface->irq_lock, flags);
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTEN);
 	int_temp |= int_mask;
 	rkcif_mipi_write(interface, RKCIF_MIPI_INTEN, int_temp);

@@ -753,6 +751,7 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTSTAT);
 	int_temp &= ~int_mask;
 	rkcif_mipi_write(interface, RKCIF_MIPI_INTSTAT, int_temp);
+	spin_unlock_irqrestore(&interface->irq_lock, flags);
 
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_FRAME0_VLW_Y, vlw);
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_FRAME1_VLW_Y, vlw);

@@ -769,26 +768,21 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 	 */
 	rkcif_mipi_write(interface, RKCIF_MIPI_CTRL, RK3588_MIPI_CTRL_CAP_EN);
 
-	ret = 0;
-
-out:
-	v4l2_subdev_unlock_state(state);
-	return ret;
+	return 0;
 }
 
 static void rkcif_mipi_stop_streaming(struct rkcif_stream *stream)
 {
 	struct rkcif_interface *interface = stream->interface;
-	struct v4l2_subdev_state *state;
 	u32 int_temp = 0, int_mask = 0;
-
-	state = v4l2_subdev_lock_and_get_active_state(&interface->sd);
+	unsigned long flags;
 
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_CTRL0, 0);
 
 	int_mask |= RKCIF_MIPI_INT_FRAME0_END(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME1_END(stream->id);
 
+	spin_lock_irqsave(&interface->irq_lock, flags);
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTEN);
 	int_temp &= ~int_mask;
 	rkcif_mipi_write(interface, RKCIF_MIPI_INTEN, int_temp);

@@ -796,10 +790,9 @@ static void rkcif_mipi_stop_streaming(struct rkcif_stream *stream)
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTSTAT);
 	int_temp &= ~int_mask;
 	rkcif_mipi_write(interface, RKCIF_MIPI_INTSTAT, int_temp);
+	spin_unlock_irqrestore(&interface->irq_lock, flags);
 
 	stream->stopping = false;
-
-	v4l2_subdev_unlock_state(state);
 }
 
 static void rkcif_mipi_set_crop(struct rkcif_stream *stream, u16 left, u16 top)

@@ -881,6 +874,7 @@ int rkcif_mipi_register(struct rkcif_device *rkcif)
 		interface->in_fmts_num = ARRAY_SIZE(mipi_in_fmts);
 		interface->set_crop = rkcif_mipi_set_crop;
 		interface->streams_num = 0;
+		spin_lock_init(&interface->irq_lock);
 		ret = rkcif_interface_register(rkcif, interface);
 		if (ret)
 			continue;

index 4d9211ba9bda8..16a5ecb25c2fb 100644
@@ -198,6 +198,9 @@ struct rkcif_interface {
 		struct rkcif_dvp dvp;
 	};
 
+	/* interrupt enable and status are shared by the streams of a block */
+	spinlock_t irq_lock;
+
 	void (*set_crop)(struct rkcif_stream *stream, u16 left, u16 top);
 };
 

index 53cfd37bf02bd..af0134e6c4c67 100644
@@ -7,6 +7,7 @@
  * Copyright (C) 2025 Collabora, Ltd.
  */
 
+#include <linux/debugfs.h>
 #include <linux/interrupt.h>
 
 #include <media/mipi-csi2.h>

@@ -44,6 +45,35 @@
 
 #define RKCIF_MIPI_INT_FRAME0_END(id) BIT(8 + (id) * 2 + 0)
 #define RKCIF_MIPI_INT_FRAME1_END(id) BIT(8 + (id) * 2 + 1)
+#define RKCIF_MIPI_INT_ALL_END GENMASK(15, 8)
+
+#define RK3568_MIPI_INT_DMA_Y_FIFO_OVERFLOW BIT(16)
+#define RK3568_MIPI_INT_DMA_UV_FIFO_OVERFLOW BIT(17)
+#define RK3568_MIPI_INT_CONFIG_FIFO_OVERFLOW BIT(18)
+#define RK3568_MIPI_INT_BANDWIDTH_LACK BIT(19)
+#define RK3568_MIPI_INT_RX_FIFO_OVERFLOW BIT(20)
+
+#define RK3588_MIPI_INT_DMA_Y_FIFO_OVERFLOW BIT(16)
+#define RK3588_MIPI_INT_DMA_UV_FIFO_OVERFLOW BIT(17)
+#define RK3588_MIPI_INT_BANDWIDTH_LACK BIT(18)
+#define RK3588_MIPI_INT_RX_FIFO_OVERFLOW BIT(19)
+#define RK3588_MIPI_INT_SIZE_ERROR GENMASK(27, 24)
+
+static const struct rkcif_mipi_error rk3568_mipi_errors[] = {
+	{ RK3568_MIPI_INT_DMA_Y_FIFO_OVERFLOW, "dma_y_fifo_overflow" },
+	{ RK3568_MIPI_INT_DMA_UV_FIFO_OVERFLOW, "dma_uv_fifo_overflow" },
+	{ RK3568_MIPI_INT_CONFIG_FIFO_OVERFLOW, "config_fifo_overflow" },
+	{ RK3568_MIPI_INT_BANDWIDTH_LACK, "bandwidth_lack" },
+	{ RK3568_MIPI_INT_RX_FIFO_OVERFLOW, "rx_fifo_overflow" },
+};
+
+static const struct rkcif_mipi_error rk3588_mipi_errors[] = {
+	{ RK3588_MIPI_INT_DMA_Y_FIFO_OVERFLOW, "dma_y_fifo_overflow" },
+	{ RK3588_MIPI_INT_DMA_UV_FIFO_OVERFLOW, "dma_uv_fifo_overflow" },
+	{ RK3588_MIPI_INT_BANDWIDTH_LACK, "bandwidth_lack" },
+	{ RK3588_MIPI_INT_RX_FIFO_OVERFLOW, "rx_fifo_overflow" },
+	{ RK3588_MIPI_INT_SIZE_ERROR, "size_error" },
+};
 
 static const struct rkcif_output_fmt mipi_out_fmts[] = {
 	/* YUV formats */

@@ -420,10 +450,14 @@ rkcif_rk3568_mipi_ctrl0(struct rkcif_stream *stream,
 const struct rkcif_mipi_match_data rkcif_rk3568_vicap_mipi_match_data = {
 	.mipi_num = 1,
 	.mipi_ctrl0 = rkcif_rk3568_mipi_ctrl0,
+	.errors = rk3568_mipi_errors,
+	.errors_num = ARRAY_SIZE(rk3568_mipi_errors),
 	.regs = {
 		[RKCIF_MIPI_CTRL] = 0x20,
 		[RKCIF_MIPI_INTEN] = 0xa4,
 		[RKCIF_MIPI_INTSTAT] = 0xa8,
+		[RKCIF_MIPI_LINE_CNT_ID0_1] = 0xb4,
+		[RKCIF_MIPI_LINE_CNT_ID2_3] = 0xb8,
 	},
 	.regs_id = {
 		[RKCIF_ID0] = {

@@ -531,10 +565,14 @@ rkcif_rk3588_mipi_ctrl0(struct rkcif_stream *stream,
 const struct rkcif_mipi_match_data rkcif_rk3588_vicap_mipi_match_data = {
 	.mipi_num = 6,
 	.mipi_ctrl0 = rkcif_rk3588_mipi_ctrl0,
+	.errors = rk3588_mipi_errors,
+	.errors_num = ARRAY_SIZE(rk3588_mipi_errors),
 	.regs = {
 		[RKCIF_MIPI_CTRL] = 0x20,
 		[RKCIF_MIPI_INTEN] = 0x74,
 		[RKCIF_MIPI_INTSTAT] = 0x78,
+		[RKCIF_MIPI_LINE_CNT_ID0_1] = 0x84,
+		[RKCIF_MIPI_LINE_CNT_ID2_3] = 0x88,
 	},
 	.regs_id = {
 		[RKCIF_ID0] = {

@@ -699,6 +737,53 @@ rkcif_mipi_stream_read(struct rkcif_stream *stream, unsigned int index)
 	return readl(stream->rkcif->base_addr + addr);
 }
 
+static u32 rkcif_mipi_error_mask(struct rkcif_interface *interface)
+{
+	const struct rkcif_mipi_match_data *match_data =
+		interface->rkcif->match_data->mipi;
+	unsigned int i;
+	u32 mask = 0;
+
+	for (i = 0; i < match_data->errors_num; i++)
+		mask |= match_data->errors[i].mask;
+
+	return mask;
+}
+
+static void rkcif_mipi_handle_errors(struct rkcif_interface *interface,
+				     u32 intstat)
+{
+	const struct rkcif_mipi_match_data *match_data =
+		interface->rkcif->match_data->mipi;
+	unsigned int i;
+
+	intstat &= rkcif_mipi_error_mask(interface);
+	if (!intstat)
+		return;
+
+	for (i = 0; i < match_data->errors_num; i++)
+		if (intstat & match_data->errors[i].mask)
+			interface->error_count[i]++;
+
+	dev_warn_ratelimited(interface->rkcif->dev, "%s: capture errors %#x\n",
+			     interface->sd.name, intstat);
+}
+
+static void rkcif_mipi_debugfs_init(struct rkcif_interface *interface)
+{
+	const struct rkcif_mipi_match_data *match_data =
+		interface->rkcif->match_data->mipi;
+	struct dentry *parent = interface->rkcif->debugfs_dir;
+	unsigned int i;
+
+	interface->debugfs_dir = debugfs_create_dir(interface->sd.name, parent);
+
+	for (i = 0; i < match_data->errors_num; i++)
+		debugfs_create_ulong(match_data->errors[i].name, 0444,
+				     interface->debugfs_dir,
+				     &interface->error_count[i]);
+}
+
 static void rkcif_mipi_queue_buffer(struct rkcif_stream *stream,
 				    unsigned int index)
 {

@@ -742,6 +827,7 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 
 	int_mask |= RKCIF_MIPI_INT_FRAME0_END(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME1_END(stream->id);
+	int_mask |= rkcif_mipi_error_mask(interface);
 
 	spin_lock_irqsave(&interface->irq_lock, flags);
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTEN);

@@ -785,6 +871,8 @@ static void rkcif_mipi_stop_streaming(struct rkcif_stream *stream)
 	spin_lock_irqsave(&interface->irq_lock, flags);
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTEN);
 	int_temp &= ~int_mask;
+	if (!(int_temp & RKCIF_MIPI_INT_ALL_END))
+		int_temp &= ~rkcif_mipi_error_mask(interface);
 	rkcif_mipi_write(interface, RKCIF_MIPI_INTEN, int_temp);
 
 	int_temp = rkcif_mipi_read(interface, RKCIF_MIPI_INTSTAT);

@@ -836,6 +924,8 @@ irqreturn_t rkcif_mipi_isr(int irq, void *ctx)
 		if (intstat)
 			ret = IRQ_HANDLED;
 
+		rkcif_mipi_handle_errors(interface, intstat);
+
 		for (unsigned int j = 0; j < interface->streams_num; j++) {
 			struct rkcif_stream *stream = &interface->streams[j];
 

@@ -879,6 +969,8 @@ int rkcif_mipi_register(struct rkcif_device *rkcif)
 		if (ret)
 			continue;
 
+		rkcif_mipi_debugfs_init(interface);
+
 		for (unsigned int j = 0; j < RKCIF_ID_MAX; j++) {
 			struct rkcif_stream *stream = &interface->streams[j];
 

@@ -906,6 +998,7 @@ int rkcif_mipi_register(struct rkcif_device *rkcif)
 		for (unsigned int j = 0; j < interface->streams_num; j++)
 			rkcif_stream_unregister(&interface->streams[j]);
 
+		debugfs_remove_recursive(interface->debugfs_dir);
 		rkcif_interface_unregister(interface);
 	}
 	return ret;

@@ -923,6 +1016,7 @@ void rkcif_mipi_unregister(struct rkcif_device *rkcif)
 		for (unsigned int j = 0; j < interface->streams_num; j++)
 			rkcif_stream_unregister(&interface->streams[j]);
 
+		debugfs_remove_recursive(interface->debugfs_dir);
 		rkcif_interface_unregister(interface);
 	}
 }

index 16a5ecb25c2fb..13708435dd432 100644
@@ -28,6 +28,7 @@
 
 #define RKCIF_DRIVER_NAME "rockchip-cif"
 #define RKCIF_CLK_MAX	  5
+#define RKCIF_MIPI_ERRORS_MAX 5
 
 enum rkcif_format_type {
 	RKCIF_FMT_TYPE_INVALID,

@@ -198,18 +199,28 @@ struct rkcif_interface {
 		struct rkcif_dvp dvp;
 	};
 
+	struct dentry *debugfs_dir;
+	unsigned long error_count[RKCIF_MIPI_ERRORS_MAX];
+
 	/* interrupt enable and status are shared by the streams of a block */
 	spinlock_t irq_lock;
 
 	void (*set_crop)(struct rkcif_stream *stream, u16 left, u16 top);
 };
 
+struct rkcif_mipi_error {
+	u32 mask;
+	const char *name;
+};
+
 struct rkcif_mipi_match_data {
 	unsigned int mipi_num;
 	unsigned int regs[RKCIF_MIPI_REGISTER_MAX];
 	unsigned int regs_id[RKCIF_ID_MAX][RKCIF_MIPI_ID_REGISTER_MAX];
 	u32 (*mipi_ctrl0)(struct rkcif_stream *stream,
 			  const struct rkcif_output_fmt *active_out_fmt);
+	const struct rkcif_mipi_error *errors;
+	unsigned int errors_num;
 	struct {
 		unsigned int offset;
 	} blocks[RKCIF_MIPI_MAX - RKCIF_MIPI_BASE];

@@ -248,6 +259,7 @@ struct rkcif_device {
 	struct media_device media_dev;
 	struct v4l2_device v4l2_dev;
 	struct v4l2_async_notifier notifier;
+	struct dentry *debugfs_dir;
 };
 
 #endif

index fbc8ed78d99ea..630a5ccf59c11 100644
@@ -10,6 +10,7 @@
  */
 
 #include <linux/clk.h>
+#include <linux/debugfs.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/mfd/syscon.h>

@@ -231,6 +232,8 @@ static int rkcif_probe(struct platform_device *pdev)
 	v4l2_async_nf_init(&rkcif->notifier, &rkcif->v4l2_dev);
 	rkcif->notifier.ops = &rkcif_notifier_ops;
 
+	rkcif->debugfs_dir = debugfs_create_dir(dev_name(dev), NULL);
+
 	ret = rkcif_register(rkcif);
 	if (ret) {
 		dev_err(dev, "failed to register media entities: %d\n", ret);

@@ -246,6 +249,7 @@ static int rkcif_probe(struct platform_device *pdev)
 err_rkcif_unregister:
 	rkcif_unregister(rkcif);
 err_notifier_cleanup:
+	debugfs_remove_recursive(rkcif->debugfs_dir);
 	v4l2_async_nf_cleanup(&rkcif->notifier);
 	media_device_unregister(&rkcif->media_dev);
 err_v4l2_dev_unregister:

@@ -262,6 +266,7 @@ static void rkcif_remove(struct platform_device *pdev)
 
 	v4l2_async_nf_unregister(&rkcif->notifier);
 	rkcif_unregister(rkcif);
+	debugfs_remove_recursive(rkcif->debugfs_dir);
 	v4l2_async_nf_cleanup(&rkcif->notifier);
 	media_device_unregister(&rkcif->media_dev);
 	v4l2_device_unregister(&rkcif->v4l2_dev);

index 3cf7ee19de300..92da7497b902a 100644
@@ -132,6 +132,8 @@ enum rkcif_mipi_register_index {
 	RKCIF_MIPI_CTRL,
 	RKCIF_MIPI_INTEN,
 	RKCIF_MIPI_INTSTAT,
+	RKCIF_MIPI_LINE_CNT_ID0_1,
+	RKCIF_MIPI_LINE_CNT_ID2_3,
 	RKCIF_MIPI_REGISTER_MAX
 };
 

index af0134e6c4c67..0cef1cc35eedd 100644
@@ -43,10 +43,17 @@
 #define RKCIF_MIPI_CTRL0_VC_ID(id)    ((id) << 8)
 #define RKCIF_MIPI_CTRL0_CAP_EN	      BIT(0)
 
+#define RKCIF_MIPI_INT_FRAME0_START(id) BIT((id) * 2 + 0)
+#define RKCIF_MIPI_INT_FRAME1_START(id) BIT((id) * 2 + 1)
 #define RKCIF_MIPI_INT_FRAME0_END(id) BIT(8 + (id) * 2 + 0)
 #define RKCIF_MIPI_INT_FRAME1_END(id) BIT(8 + (id) * 2 + 1)
 #define RKCIF_MIPI_INT_ALL_END GENMASK(15, 8)
 
+#define RKCIF_MIPI_LINE_CNT_MASK GENMASK(13, 0)
+
+/* a slipped frame boundary persists, so a second frame confirms it */
+#define RKCIF_MIPI_MISALIGNED_FRAMES 2
+
 #define RK3568_MIPI_INT_DMA_Y_FIFO_OVERFLOW BIT(16)
 #define RK3568_MIPI_INT_DMA_UV_FIFO_OVERFLOW BIT(17)
 #define RK3568_MIPI_INT_CONFIG_FIFO_OVERFLOW BIT(18)

@@ -782,6 +789,41 @@ static void rkcif_mipi_debugfs_init(struct rkcif_interface *interface)
 		debugfs_create_ulong(match_data->errors[i].name, 0444,
 				     interface->debugfs_dir,
 				     &interface->error_count[i]);
+	debugfs_create_ulong("restarts", 0444, interface->debugfs_dir,
+			     &interface->restarts);
+}
+
+static u32 rkcif_mipi_line_cnt(struct rkcif_stream *stream)
+{
+	unsigned int index = RKCIF_MIPI_LINE_CNT_ID0_1 + stream->id / 2;
+	u32 val = rkcif_mipi_read(stream->interface, index);
+
+	return (val >> (stream->id % 2 * 16)) & RKCIF_MIPI_LINE_CNT_MASK;
+}
+
+/* the DMA frame boundary is a line count that only a block reset resyncs */
+static void rkcif_mipi_check_alignment(struct rkcif_stream *stream)
+{
+	u32 line;
+
+	if (!stream->streaming || stream->stopping || stream->restart_pending ||
+	    stream->realign_disabled)
+		return;
+
+	line = rkcif_mipi_line_cnt(stream);
+	if (!line) {
+		stream->misaligned_frames = 0;
+		return;
+	}
+
+	if (++stream->misaligned_frames < RKCIF_MIPI_MISALIGNED_FRAMES)
+		return;
+
+	stream->misaligned_frames = 0;
+	dev_warn(stream->rkcif->dev,
+		 "%s: frame starts at line %u, restarting the capture\n",
+		 stream->vdev.name, line);
+	rkcif_stream_restart(stream);
 }
 
 static void rkcif_mipi_queue_buffer(struct rkcif_stream *stream,

@@ -825,6 +867,8 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 
 	ctrl1 = RKCIF_XY_COORD(width, height);
 
+	int_mask |= RKCIF_MIPI_INT_FRAME0_START(stream->id);
+	int_mask |= RKCIF_MIPI_INT_FRAME1_START(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME0_END(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME1_END(stream->id);
 	int_mask |= rkcif_mipi_error_mask(interface);

@@ -865,6 +909,8 @@ static void rkcif_mipi_stop_streaming(struct rkcif_stream *stream)
 
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_CTRL0, 0);
 
+	int_mask |= RKCIF_MIPI_INT_FRAME0_START(stream->id);
+	int_mask |= RKCIF_MIPI_INT_FRAME1_START(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME0_END(stream->id);
 	int_mask |= RKCIF_MIPI_INT_FRAME1_END(stream->id);
 

@@ -929,6 +975,10 @@ irqreturn_t rkcif_mipi_isr(int irq, void *ctx)
 		for (unsigned int j = 0; j < interface->streams_num; j++) {
 			struct rkcif_stream *stream = &interface->streams[j];
 
+			if (intstat & RKCIF_MIPI_INT_FRAME0_START(stream->id) ||
+			    intstat & RKCIF_MIPI_INT_FRAME1_START(stream->id))
+				rkcif_mipi_check_alignment(stream);
+
 			if (intstat & RKCIF_MIPI_INT_FRAME0_END(stream->id) ||
 			    intstat & RKCIF_MIPI_INT_FRAME1_END(stream->id)) {
 				ret = IRQ_HANDLED;

@@ -939,6 +989,9 @@ irqreturn_t rkcif_mipi_isr(int irq, void *ctx)
 					continue;
 				}
 
+				if (stream->restart_pending)
+					continue;
+
 				rkcif_stream_pingpong(stream);
 			}
 		}

index 13708435dd432..1efc74d488d40 100644
@@ -14,6 +14,7 @@
 #include <linux/clk.h>
 #include <linux/mutex.h>
 #include <linux/regmap.h>
+#include <linux/workqueue.h>
 
 #include <media/media-device.h>
 #include <media/media-entity.h>

@@ -158,6 +159,12 @@ struct rkcif_stream {
 	bool stopping;
 	wait_queue_head_t wq_stopped;
 
+	bool streaming;
+	bool restart_pending;
+	bool realign_disabled;
+	unsigned int misaligned_frames;
+	struct work_struct restart_work;
+
 	/* queue of available buffers plus spinlock that protects it */
 	spinlock_t driver_queue_lock;
 	struct list_head driver_queue;

@@ -201,6 +208,7 @@ struct rkcif_interface {
 
 	struct dentry *debugfs_dir;
 	unsigned long error_count[RKCIF_MIPI_ERRORS_MAX];
+	unsigned long restarts;
 
 	/* interrupt enable and status are shared by the streams of a block */
 	spinlock_t irq_lock;

100 lines not on this page · raw message

index 590faf5d1a87a..61347179818f2 100644
@@ -20,6 +20,8 @@
 
 void rkcif_stream_pingpong(struct rkcif_stream *stream);
 
+void rkcif_stream_restart(struct rkcif_stream *stream);
+
 int rkcif_stream_register(struct rkcif_device *rkcif,
 			  struct rkcif_stream *stream);
 

index 0cef1cc35eedd..a00fe64a1a9d4 100644
@@ -37,7 +37,12 @@
 #define RK3588_MIPI_CTRL0_CROP_EN     BIT(4)
 #define RK3588_MIPI_CTRL0_PARSE(type) ((type) << 1)
 
-#define RK3588_MIPI_CTRL_CAP_EN       BIT(0)
+#define RKCIF_MIPI_CTRL_PRESS_VALUE(x) ((x) << 13)
+#define RKCIF_MIPI_CTRL_PRESS_ENABLE BIT(12)
+#define RKCIF_MIPI_CTRL_HURRY_VALUE(x) ((x) << 5)
+#define RKCIF_MIPI_CTRL_HURRY_ENABLE BIT(4)
+#define RKCIF_MIPI_CTRL_WATER_LINE_25 (0x2 << 1)
+#define RKCIF_MIPI_CTRL_WATER_LINE_ENABLE BIT(0)
 
 #define RKCIF_MIPI_CTRL0_DT_ID(id)    ((id) << 10)
 #define RKCIF_MIPI_CTRL0_VC_ID(id)    ((id) << 8)

@@ -891,12 +896,13 @@ static int rkcif_mipi_start_streaming(struct rkcif_stream *stream)
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_CTRL1, ctrl1);
 	rkcif_mipi_stream_write(stream, RKCIF_MIPI_CTRL0, ctrl0);
 
-	/*
-	 * TODO: This bit has a different meaning on the RK3568, but it is
-	 * set there by default anyway. While correct, this is not exactly
-	 * nice and shall be reworked during the next refactoring.
-	 */
-	rkcif_mipi_write(interface, RKCIF_MIPI_CTRL, RK3588_MIPI_CTRL_CAP_EN);
+	rkcif_mipi_write(interface, RKCIF_MIPI_CTRL,
+			 RKCIF_MIPI_CTRL_PRESS_VALUE(3) |
+				 RKCIF_MIPI_CTRL_PRESS_ENABLE |
+				 RKCIF_MIPI_CTRL_HURRY_VALUE(3) |
+				 RKCIF_MIPI_CTRL_HURRY_ENABLE |
+				 RKCIF_MIPI_CTRL_WATER_LINE_25 |
+				 RKCIF_MIPI_CTRL_WATER_LINE_ENABLE);
 
 	return 0;
 }

index 41e48365167e5..ae895a18f7966 100644
@@ -9,7 +9,9 @@
 
 #include <linux/bitfield.h>
 #include <linux/clk.h>
+#include <linux/debugfs.h>
 #include <linux/delay.h>
+#include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/iopoll.h>
 #include <linux/module.h>

@@ -54,6 +56,18 @@
 
 #define IPI_MEM_FLUSH_AUTO		BIT(8)
 
+#define ERR1_PHY_SOT_SYNC GENMASK(3, 0)
+#define ERR1_FRAME_BOUNDARY GENMASK(7, 4)
+#define ERR1_FRAME_SEQUENCE GENMASK(11, 8)
+#define ERR1_FRAME_DATA GENMASK(15, 12)
+#define ERR1_CRC GENMASK(28, 24)
+
+#define ERR2_PHY_ESCAPE GENMASK(3, 0)
+#define ERR2_PHY_SOT GENMASK(7, 4)
+#define ERR2_ECC_CORRECTED GENMASK(11, 8)
+#define ERR2_DATA_TYPE GENMASK(15, 12)
+#define ERR2_PHY_CODE BIT(24)
+
 enum dw_mipi_csi2rx_regs_index {
 	DW_MIPI_CSI2RX_N_LANES,
 	DW_MIPI_CSI2RX_RESETN,

@@ -100,6 +114,25 @@ struct dw_mipi_csi2rx_format {
 	u8 csi_dt;
 };
 
+struct dw_mipi_csi2rx_error {
+	enum dw_mipi_csi2rx_regs_index reg;
+	u32 mask;
+	const char *name;
+};
+
+static const struct dw_mipi_csi2rx_error dw_mipi_csi2rx_errors[] = {
+	{ DW_MIPI_CSI2RX_ERR1, ERR1_PHY_SOT_SYNC, "phy_sot_sync" },
+	{ DW_MIPI_CSI2RX_ERR1, ERR1_FRAME_BOUNDARY, "frame_boundary" },
+	{ DW_MIPI_CSI2RX_ERR1, ERR1_FRAME_SEQUENCE, "frame_sequence" },
+	{ DW_MIPI_CSI2RX_ERR1, ERR1_FRAME_DATA, "frame_data" },
+	{ DW_MIPI_CSI2RX_ERR1, ERR1_CRC, "crc" },
+	{ DW_MIPI_CSI2RX_ERR2, ERR2_PHY_ESCAPE, "phy_escape" },
+	{ DW_MIPI_CSI2RX_ERR2, ERR2_PHY_SOT, "phy_sot" },
+	{ DW_MIPI_CSI2RX_ERR2, ERR2_ECC_CORRECTED, "ecc_corrected" },
+	{ DW_MIPI_CSI2RX_ERR2, ERR2_DATA_TYPE, "data_type" },
+	{ DW_MIPI_CSI2RX_ERR2, ERR2_PHY_CODE, "phy_code" },
+};
+
 struct dw_mipi_csi2rx_device {
 	struct device *dev;
 

@@ -108,6 +141,9 @@ struct dw_mipi_csi2rx_device {
 	unsigned int clks_num;
 	struct phy *phy;
 	struct reset_control *reset;
+	bool err_irqs;
+	struct dentry *debugfs_dir;
+	unsigned long error_count[ARRAY_SIZE(dw_mipi_csi2rx_errors)];
 
 	const struct dw_mipi_csi2rx_format *formats;
 	unsigned int formats_num;

@@ -343,6 +379,76 @@ static inline u32 dw_mipi_csi2rx_read(struct dw_mipi_csi2rx_device *csi2,
 	return readl(dw_mipi_csi2rx_get_regaddr(csi2, index));
 }
 
+static void dw_mipi_csi2rx_mask_errors(struct dw_mipi_csi2rx_device *csi2,
+				       u32 msk1, u32 msk2)
+{
+	if (dw_mipi_csi2rx_has_reg(csi2, DW_MIPI_CSI2RX_MSK1))
+		dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_MSK1, msk1);
+
+	if (dw_mipi_csi2rx_has_reg(csi2, DW_MIPI_CSI2RX_MSK2))
+		dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_MSK2, msk2);
+}
+
+static irqreturn_t dw_mipi_csi2rx_err_isr(int irq, void *ctx)
+{
+	struct dw_mipi_csi2rx_device *csi2 = ctx;
+	const struct dw_mipi_csi2rx_error *error;
+	unsigned int i;
+	u32 err[2];
+
+	err[0] = dw_mipi_csi2rx_read(csi2, DW_MIPI_CSI2RX_ERR1);
+	err[1] = dw_mipi_csi2rx_read(csi2, DW_MIPI_CSI2RX_ERR2);
+	if (!err[0] && !err[1])
+		return IRQ_NONE;
+
+	for (i = 0; i < ARRAY_SIZE(dw_mipi_csi2rx_errors); i++) {
+		error = &dw_mipi_csi2rx_errors[i];
+		if (err[error->reg - DW_MIPI_CSI2RX_ERR1] & error->mask)
+			csi2->error_count[i]++;
+	}
+
+	dev_warn_ratelimited(csi2->dev, "link errors %#x %#x\n", err[0],
+			     err[1]);
+
+	return IRQ_HANDLED;
+}
+
+static int dw_mipi_csi2rx_request_irqs(struct dw_mipi_csi2rx_device *csi2,
+				       struct platform_device *pdev)
+{
+	static const char *const names[] = { "err1", "err2" };
+	unsigned int i;
+	int irq, ret;
+
+	for (i = 0; i < ARRAY_SIZE(names); i++) {
+		irq = platform_get_irq_byname_optional(pdev, names[i]);
+		if (irq == -ENXIO)
+			continue;
+		if (irq < 0)
+			return irq;
+
+		ret = devm_request_irq(&pdev->dev, irq, dw_mipi_csi2rx_err_isr,
+				       0, dev_name(&pdev->dev), csi2);
+		if (ret)
+			return ret;
+
+		csi2->err_irqs = true;
+	}
+
+	return 0;
+}
+
+static void dw_mipi_csi2rx_debugfs_init(struct dw_mipi_csi2rx_device *csi2)
+{
+	unsigned int i;
+
+	csi2->debugfs_dir = debugfs_create_dir(dev_name(csi2->dev), NULL);
+
+	for (i = 0; i < ARRAY_SIZE(dw_mipi_csi2rx_errors); i++)
+		debugfs_create_ulong(dw_mipi_csi2rx_errors[i].name, 0444,
+				     csi2->debugfs_dir, &csi2->error_count[i]);
+}
+
 static const struct dw_mipi_csi2rx_format *
 dw_mipi_csi2rx_find_format(struct dw_mipi_csi2rx_device *csi2, u32 mbus_code)
 {

@@ -425,6 +531,9 @@ static int dw_mipi_csi2rx_start(struct dw_mipi_csi2rx_device *csi2)
 	if (csi2->drvdata->dphy_deassert_reset)
 		csi2->drvdata->dphy_deassert_reset(csi2);
 
+	if (csi2->err_irqs)
+		dw_mipi_csi2rx_mask_errors(csi2, 0, ERR2_DATA_TYPE);
+
 	dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_RESETN, 1);
 
 	if (csi2->drvdata->ipi_enable)

@@ -439,11 +548,7 @@ static void dw_mipi_csi2rx_stop(struct dw_mipi_csi2rx_device *csi2)
 
 	dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_RESETN, 0);
 
-	if (dw_mipi_csi2rx_has_reg(csi2, DW_MIPI_CSI2RX_MSK1))
-		dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_MSK1, ~0);
-
-	if (dw_mipi_csi2rx_has_reg(csi2, DW_MIPI_CSI2RX_MSK2))
-		dw_mipi_csi2rx_write(csi2, DW_MIPI_CSI2RX_MSK2, ~0);
+	dw_mipi_csi2rx_mask_errors(csi2, ~0, ~0);
 }
 
 static const struct media_entity_operations dw_mipi_csi2rx_media_ops = {

@@ -985,6 +1090,10 @@ static int dw_mipi_csi2rx_probe(struct platform_device *pdev)
 		return dev_err_probe(dev, PTR_ERR(csi2->reset),
 				     "failed to get reset\n");
 
+	ret = dw_mipi_csi2rx_request_irqs(csi2, pdev);
+	if (ret)
+		return dev_err_probe(dev, ret, "failed to request irqs\n");
+
 	csi2->formats = formats;
 	csi2->formats_num = ARRAY_SIZE(formats);
 

@@ -997,6 +1106,8 @@ static int dw_mipi_csi2rx_probe(struct platform_device *pdev)
 		return dev_err_probe(dev, ret,
 				     "failed to initialize MIPI CSI-2 PHY\n");
 
+	dw_mipi_csi2rx_debugfs_init(csi2);
+
 	ret = dw_mipi_csi2rx_register(csi2);
 	if (ret)
 		goto err_phy_exit;

@@ -1004,6 +1115,7 @@ static int dw_mipi_csi2rx_probe(struct platform_device *pdev)
 	return 0;
 
 err_phy_exit:
+	debugfs_remove_recursive(csi2->debugfs_dir);
 	phy_exit(csi2->phy);
 
 	return ret;

@@ -1014,6 +1126,7 @@ static void dw_mipi_csi2rx_remove(struct platform_device *pdev)
 	struct dw_mipi_csi2rx_device *csi2 = platform_get_drvdata(pdev);
 
 	dw_mipi_csi2rx_unregister(csi2);
+	debugfs_remove_recursive(csi2->debugfs_dir);
 	phy_exit(csi2->phy);
 }
 

@@ -1041,6 +1154,8 @@ static int dw_mipi_csi2rx_runtime_resume(struct device *dev)
 		return ret;
 	}
 
+	dw_mipi_csi2rx_mask_errors(csi2, ~0, ~0);
+
 	return 0;
 }