All of lore.kernel.org
 help / color / mirror / Atom feed
From: Jiaqi Shi <shijiaqi_develop@163.com>
To: linux-media@vger.kernel.org, imx@lists.linux.dev,
	linux-staging@lists.linux.dev
Cc: slongerbeam@gmail.com, p.zabel@pengutronix.de,
	mchehab@kernel.org, gregkh@linuxfoundation.org, Frank.Li@nxp.com,
	kernel@pengutronix.de, festevam@gmail.com,
	Jiaqi Shi <shijiaqi_develop@163.com>
Subject: [PATCH 2/3] media: v4l2-core: add frame interval monitor helper
Date: Sat, 21 Nov 2026 22:14:10 +0800	[thread overview]
Message-ID: <20261121141412.319802-3-shijiaqi_develop@163.com> (raw)
In-Reply-To: <20261121141412.319802-1-shijiaqi_develop@163.com>

Move the generic frame interval monitoring implementation from i.MX
to v4l2-core. The helper supports driver-selected control and event
IDs and accepts EOF or external timestamps.

Keep the i.MX-specific input capture controls in the i.MX adapter,
sharing the original control handler and preserving the existing UAPI
and event semantics.

Select V4L2_FIM from VIDEO_IMX_MEDIA and remove the completed TODO.

Signed-off-by: Jiaqi Shi <shijiaqi_develop@163.com>
---
 drivers/media/v4l2-core/Kconfig           |   4 +
 drivers/media/v4l2-core/Makefile          |   1 +
 drivers/media/v4l2-core/v4l2-fim.c        | 324 ++++++++++++++++++++
 drivers/staging/media/imx/Kconfig         |   1 +
 drivers/staging/media/imx/TODO            |   3 -
 drivers/staging/media/imx/imx-media-fim.c | 352 ++++------------------
 include/media/v4l2-fim.h                  |  40 +++
 7 files changed, 421 insertions(+), 304 deletions(-)
 create mode 100644 drivers/media/v4l2-core/v4l2-fim.c
 delete mode 100644 drivers/staging/media/imx/TODO
 create mode 100644 include/media/v4l2-fim.h

diff --git a/drivers/media/v4l2-core/Kconfig b/drivers/media/v4l2-core/Kconfig
index d50ccac9733c..cff961b24c04 100644
--- a/drivers/media/v4l2-core/Kconfig
+++ b/drivers/media/v4l2-core/Kconfig
@@ -40,6 +40,10 @@ config VIDEO_TUNER
 config V4L2_JPEG_HELPER
 	tristate
 
+# Used by drivers that need v4l2-fim.ko
+config V4L2_FIM
+	tristate
+
 # Used by drivers that need v4l2-h264.ko
 config V4L2_H264
 	tristate
diff --git a/drivers/media/v4l2-core/Makefile b/drivers/media/v4l2-core/Makefile
index 329f0eadce99..d5f6699a2669 100644
--- a/drivers/media/v4l2-core/Makefile
+++ b/drivers/media/v4l2-core/Makefile
@@ -26,6 +26,7 @@ videodev-$(CONFIG_VIDEO_V4L2_I2C) += v4l2-i2c.o
 
 obj-$(CONFIG_V4L2_ASYNC) += v4l2-async.o
 obj-$(CONFIG_V4L2_CCI) += v4l2-cci.o
+obj-$(CONFIG_V4L2_FIM) += v4l2-fim.o
 obj-$(CONFIG_V4L2_FLASH_LED_CLASS) += v4l2-flash-led-class.o
 obj-$(CONFIG_V4L2_FWNODE) += v4l2-fwnode.o
 obj-$(CONFIG_V4L2_H264) += v4l2-h264.o
diff --git a/drivers/media/v4l2-core/v4l2-fim.c b/drivers/media/v4l2-core/v4l2-fim.c
new file mode 100644
index 000000000000..57d595196663
--- /dev/null
+++ b/drivers/media/v4l2-core/v4l2-fim.c
@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Frame Interval Monitor.
+ *
+ * Copyright (c) 2016 Mentor Graphics Inc.
+ */
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <media/v4l2-ctrls.h>
+#include <media/v4l2-fim.h>
+#include <media/v4l2-subdev.h>
+
+enum {
+	FIM_CL_ENABLE = 0,
+	FIM_CL_NUM,
+	FIM_CL_TOLERANCE_MIN,
+	FIM_CL_TOLERANCE_MAX,
+	FIM_CL_NUM_SKIP,
+};
+
+#define FIM_CL_ENABLE_DEF          0 /* FIM disabled by default */
+#define FIM_CL_NUM_DEF             8 /* average 8 frames */
+#define FIM_CL_NUM_SKIP_DEF        2 /* skip 2 frames after restart */
+#define FIM_CL_TOLERANCE_MIN_DEF  50 /* usec */
+#define FIM_CL_TOLERANCE_MAX_DEF   0 /* no max tolerance (unbounded) */
+
+struct v4l2_fim {
+	struct v4l2_subdev *sd;
+	struct v4l2_fim_config config;
+	struct v4l2_ctrl *ctrl[V4L2_FIM_NUM_CONTROLS];
+
+	spinlock_t lock; /* protect control values and monitoring state */
+
+	bool enabled;
+	int num_avg;
+	int num_skip;
+	unsigned long tolerance_min;
+	unsigned long tolerance_max;
+	bool external_timestamp;
+
+	int counter;
+	ktime_t last_ts;
+	unsigned long sum;
+	unsigned long nominal;
+	bool stream_on;
+};
+
+static void update_fim_nominal(struct v4l2_fim *fim,
+			       const struct v4l2_fract *fi)
+{
+	if (fi->denominator == 0) {
+		dev_dbg(fim->sd->dev, "no frame interval, FIM disabled\n");
+		fim->enabled = false;
+		return;
+	}
+
+	fim->nominal = DIV_ROUND_CLOSEST_ULL(1000000ULL * (u64)fi->numerator,
+					     fi->denominator);
+
+	dev_dbg(fim->sd->dev, "FI=%lu usec\n", fim->nominal);
+}
+
+static void reset_fim(struct v4l2_fim *fim, bool curval)
+{
+	struct v4l2_ctrl *en = fim->ctrl[FIM_CL_ENABLE];
+	struct v4l2_ctrl *num = fim->ctrl[FIM_CL_NUM];
+	struct v4l2_ctrl *skip = fim->ctrl[FIM_CL_NUM_SKIP];
+	struct v4l2_ctrl *tol_min = fim->ctrl[FIM_CL_TOLERANCE_MIN];
+	struct v4l2_ctrl *tol_max = fim->ctrl[FIM_CL_TOLERANCE_MAX];
+
+	if (fim->config.external_timestamp)
+		fim->external_timestamp =
+			fim->config.external_timestamp(fim->config.priv, curval);
+
+	if (curval) {
+		fim->enabled = en->cur.val;
+		fim->num_avg = num->cur.val;
+		fim->num_skip = skip->cur.val;
+		fim->tolerance_min = tol_min->cur.val;
+		fim->tolerance_max = tol_max->cur.val;
+	} else {
+		fim->enabled = en->val;
+		fim->num_avg = num->val;
+		fim->num_skip = skip->val;
+		fim->tolerance_min = tol_min->val;
+		fim->tolerance_max = tol_max->val;
+	}
+
+	/* disable tolerance range if max <= min */
+	if (fim->tolerance_max <= fim->tolerance_min)
+		fim->tolerance_max = 0;
+
+	/* num_skip must be >= 1 if input capture not used */
+	if (!fim->external_timestamp)
+		fim->num_skip = max_t(int, fim->num_skip, 1);
+
+	fim->counter = -fim->num_skip;
+	fim->sum = 0;
+}
+
+void v4l2_fim_reset(struct v4l2_fim *fim, bool curval)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&fim->lock, flags);
+	reset_fim(fim, curval);
+	spin_unlock_irqrestore(&fim->lock, flags);
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_reset);
+
+static void send_fim_event(struct v4l2_fim *fim)
+{
+	struct v4l2_event ev = {
+		.type = fim->config.event_type,
+	};
+
+	v4l2_subdev_notify_event(fim->sd, &ev);
+}
+
+/*
+ * Monitor an averaged frame interval. If the average deviates too much
+ * from the nominal frame rate, send the frame interval error event. The
+ * frame intervals are averaged in order to quiet noise from
+ * (presumably random) interrupt latency.
+ */
+static void frame_interval_monitor(struct v4l2_fim *fim, ktime_t timestamp)
+{
+	long long interval, error;
+	unsigned long error_avg;
+	bool send_event = false;
+
+	if (!fim->enabled || ++fim->counter <= 0)
+		goto out_update_ts;
+
+	/* max error is less than 100µs, so use 32-bit division or fail */
+	interval = ktime_to_ns(ktime_sub(timestamp, fim->last_ts));
+	error = abs(interval - NSEC_PER_USEC * (s64)fim->nominal);
+	if (error > U32_MAX)
+		error = U32_MAX;
+	else
+		error = abs((u32)error / NSEC_PER_USEC);
+
+	if (fim->tolerance_max && error >= fim->tolerance_max) {
+		dev_dbg(fim->sd->dev,
+			"FIM: %llu ignored, out of tolerance bounds\n",
+			error);
+		fim->counter--;
+		goto out_update_ts;
+	}
+
+	fim->sum += error;
+
+	if (fim->counter == fim->num_avg) {
+		error_avg = DIV_ROUND_CLOSEST(fim->sum, fim->num_avg);
+
+		if (error_avg > fim->tolerance_min)
+			send_event = true;
+
+		dev_dbg(fim->sd->dev, "FIM: error: %lu usec%s\n",
+			error_avg, send_event ? " (!!!)" : "");
+
+		fim->counter = 0;
+		fim->sum = 0;
+	}
+
+out_update_ts:
+	fim->last_ts = timestamp;
+	if (send_event)
+		send_fim_event(fim);
+}
+
+void v4l2_fim_eof_monitor(struct v4l2_fim *fim, ktime_t timestamp)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&fim->lock, flags);
+
+	if (!fim->external_timestamp)
+		frame_interval_monitor(fim, timestamp);
+
+	spin_unlock_irqrestore(&fim->lock, flags);
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_eof_monitor);
+
+void v4l2_fim_monitor_timestamp(struct v4l2_fim *fim, ktime_t timestamp)
+{
+	unsigned long flags;
+
+	spin_lock_irqsave(&fim->lock, flags);
+	frame_interval_monitor(fim, timestamp);
+	spin_unlock_irqrestore(&fim->lock, flags);
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_monitor_timestamp);
+
+void v4l2_fim_set_stream(struct v4l2_fim *fim,
+			 const struct v4l2_fract *fi, bool on)
+{
+	unsigned long flags;
+
+	v4l2_ctrl_lock(fim->ctrl[FIM_CL_ENABLE]);
+
+	if (fim->stream_on == on)
+		goto out;
+
+	if (on) {
+		spin_lock_irqsave(&fim->lock, flags);
+		reset_fim(fim, true);
+		update_fim_nominal(fim, fi);
+		spin_unlock_irqrestore(&fim->lock, flags);
+
+		if (fim->external_timestamp && fim->enabled && !fim->num_skip &&
+		    fim->config.wait_first_timestamp)
+			fim->config.wait_first_timestamp(fim->config.priv);
+	}
+
+	fim->stream_on = on;
+out:
+	v4l2_ctrl_unlock(fim->ctrl[FIM_CL_ENABLE]);
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_set_stream);
+
+bool v4l2_fim_is_streaming(struct v4l2_fim *fim)
+{
+	return fim->stream_on;
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_is_streaming);
+
+static int fim_s_ctrl(struct v4l2_ctrl *ctrl)
+{
+	struct v4l2_fim *fim = ctrl->priv;
+	unsigned long flags;
+
+	spin_lock_irqsave(&fim->lock, flags);
+	reset_fim(fim, false);
+	spin_unlock_irqrestore(&fim->lock, flags);
+
+	return 0;
+}
+
+static const struct v4l2_ctrl_ops fim_ctrl_ops = {
+	.s_ctrl = fim_s_ctrl,
+};
+
+static const struct v4l2_ctrl_config fim_ctrl[] = {
+	[FIM_CL_ENABLE] = {
+		.ops = &fim_ctrl_ops,
+		.name = "FIM Enable",
+		.type = V4L2_CTRL_TYPE_BOOLEAN,
+		.def = FIM_CL_ENABLE_DEF,
+		.min = 0,
+		.max = 1,
+		.step = 1,
+	},
+	[FIM_CL_NUM] = {
+		.ops = &fim_ctrl_ops,
+		.name = "FIM Num Average",
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.def = FIM_CL_NUM_DEF,
+		.min =  1,
+		.max = 64,
+		.step = 1,
+	},
+	[FIM_CL_TOLERANCE_MIN] = {
+		.ops = &fim_ctrl_ops,
+		.name = "FIM Tolerance Min",
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.def = FIM_CL_TOLERANCE_MIN_DEF,
+		.min =    2,
+		.max =  200,
+		.step =  1,
+	},
+	[FIM_CL_TOLERANCE_MAX] = {
+		.ops = &fim_ctrl_ops,
+		.name = "FIM Tolerance Max",
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.def = FIM_CL_TOLERANCE_MAX_DEF,
+		.min =    0,
+		.max =  500,
+		.step =   1,
+	},
+	[FIM_CL_NUM_SKIP] = {
+		.ops = &fim_ctrl_ops,
+		.name = "FIM Num Skip",
+		.type = V4L2_CTRL_TYPE_INTEGER,
+		.def = FIM_CL_NUM_SKIP_DEF,
+		.min =   0,
+		.max = 256,
+		.step = 1,
+	},
+};
+
+struct v4l2_fim *v4l2_fim_init(struct v4l2_subdev *sd,
+			       struct v4l2_ctrl_handler *hdlr,
+			       const struct v4l2_fim_config *config)
+{
+	struct v4l2_fim *fim;
+	int i;
+
+	fim = devm_kzalloc(sd->dev, sizeof(*fim), GFP_KERNEL);
+	if (!fim)
+		return ERR_PTR(-ENOMEM);
+
+	fim->sd = sd;
+	fim->config = *config;
+	spin_lock_init(&fim->lock);
+
+	for (i = 0; i < V4L2_FIM_NUM_CONTROLS; i++) {
+		struct v4l2_ctrl_config cfg = fim_ctrl[i];
+
+		cfg.id = config->ctrl_base + i;
+		fim->ctrl[i] = v4l2_ctrl_new_custom(hdlr, &cfg, fim);
+	}
+	if (hdlr->error)
+		return ERR_PTR(hdlr->error);
+
+	v4l2_ctrl_cluster(V4L2_FIM_NUM_CONTROLS, fim->ctrl);
+
+	return fim;
+}
+EXPORT_SYMBOL_GPL(v4l2_fim_init);
+
+MODULE_DESCRIPTION("V4L2 frame interval monitor helpers");
+MODULE_LICENSE("GPL");
diff --git a/drivers/staging/media/imx/Kconfig b/drivers/staging/media/imx/Kconfig
index 1cd48028b641..f559b9979039 100644
--- a/drivers/staging/media/imx/Kconfig
+++ b/drivers/staging/media/imx/Kconfig
@@ -6,6 +6,7 @@ config VIDEO_IMX_MEDIA
 	depends on VIDEO_DEV
 	depends on IMX_IPUV3_CORE
 	select MEDIA_CONTROLLER
+	select V4L2_FIM
 	select V4L2_FWNODE
 	select V4L2_MEM2MEM_DEV
 	select VIDEOBUF2_DMA_CONTIG
diff --git a/drivers/staging/media/imx/TODO b/drivers/staging/media/imx/TODO
deleted file mode 100644
index 43cd030d4bbd..000000000000
--- a/drivers/staging/media/imx/TODO
+++ /dev/null
@@ -1,3 +0,0 @@
-
-- The Frame Interval Monitor could be exported to v4l2-core for
-  general use.
diff --git a/drivers/staging/media/imx/imx-media-fim.c b/drivers/staging/media/imx/imx-media-fim.c
index ccbc0371fba2..b6467e29ac28 100644
--- a/drivers/staging/media/imx/imx-media-fim.c
+++ b/drivers/staging/media/imx/imx-media-fim.c
@@ -4,68 +4,31 @@
  *
  * Copyright (c) 2016 Mentor Graphics Inc.
  */
-#include <linux/delay.h>
+#include <linux/completion.h>
 #include <linux/irq.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
+#include <linux/jiffies.h>
 #include <linux/slab.h>
-#include <linux/spinlock.h>
 #include <media/v4l2-ctrls.h>
+#include <media/v4l2-fim.h>
 #include <media/v4l2-subdev.h>
 #include <media/imx.h>
 #include "imx-media.h"
 
-enum {
-	FIM_CL_ENABLE = 0,
-	FIM_CL_NUM,
-	FIM_CL_TOLERANCE_MIN,
-	FIM_CL_TOLERANCE_MAX,
-	FIM_CL_NUM_SKIP,
-	FIM_NUM_CONTROLS,
-};
-
 enum {
 	FIM_CL_ICAP_EDGE = 0,
 	FIM_CL_ICAP_CHANNEL,
 	FIM_NUM_ICAP_CONTROLS,
 };
 
-#define FIM_CL_ENABLE_DEF          0 /* FIM disabled by default */
-#define FIM_CL_NUM_DEF             8 /* average 8 frames */
-#define FIM_CL_NUM_SKIP_DEF        2 /* skip 2 frames after restart */
-#define FIM_CL_TOLERANCE_MIN_DEF  50 /* usec */
-#define FIM_CL_TOLERANCE_MAX_DEF   0 /* no max tolerance (unbounded) */
-
 struct imx_media_fim {
-	/* the owning subdev of this fim instance */
 	struct v4l2_subdev *sd;
-
-	/* FIM's control handler */
+	struct v4l2_fim *core;
 	struct v4l2_ctrl_handler ctrl_handler;
+	struct v4l2_ctrl *icap_ctrl[FIM_NUM_ICAP_CONTROLS];
 
-	/* control clusters */
-	struct v4l2_ctrl  *ctrl[FIM_NUM_CONTROLS];
-	struct v4l2_ctrl  *icap_ctrl[FIM_NUM_ICAP_CONTROLS];
-
-	spinlock_t        lock; /* protect control values */
-
-	/* current control values */
-	bool              enabled;
-	int               num_avg;
-	int               num_skip;
-	unsigned long     tolerance_min; /* usec */
-	unsigned long     tolerance_max; /* usec */
-	/* input capture method of measuring FI */
-	int               icap_channel;
-	int               icap_flags;
-
-	int               counter;
-	ktime_t		  last_ts;
-	unsigned long     sum;       /* usec */
-	unsigned long     nominal;   /* usec */
-
+	int icap_channel;
+	int icap_flags;
 	struct completion icap_first_event;
-	bool              stream_on;
 };
 
 static bool icap_enabled(struct imx_media_fim *fim)
@@ -73,171 +36,53 @@ static bool icap_enabled(struct imx_media_fim *fim)
 	return fim->icap_flags != IRQ_TYPE_NONE;
 }
 
-static void update_fim_nominal(struct imx_media_fim *fim,
-			       const struct v4l2_fract *fi)
-{
-	if (fi->denominator == 0) {
-		dev_dbg(fim->sd->dev, "no frame interval, FIM disabled\n");
-		fim->enabled = false;
-		return;
-	}
-
-	fim->nominal = DIV_ROUND_CLOSEST_ULL(1000000ULL * (u64)fi->numerator,
-					     fi->denominator);
-
-	dev_dbg(fim->sd->dev, "FI=%lu usec\n", fim->nominal);
-}
-
-static void reset_fim(struct imx_media_fim *fim, bool curval)
+static bool imx_fim_external_timestamp(void *priv, bool curval)
 {
+	struct imx_media_fim *fim = priv;
 	struct v4l2_ctrl *icap_chan = fim->icap_ctrl[FIM_CL_ICAP_CHANNEL];
 	struct v4l2_ctrl *icap_edge = fim->icap_ctrl[FIM_CL_ICAP_EDGE];
-	struct v4l2_ctrl *en = fim->ctrl[FIM_CL_ENABLE];
-	struct v4l2_ctrl *num = fim->ctrl[FIM_CL_NUM];
-	struct v4l2_ctrl *skip = fim->ctrl[FIM_CL_NUM_SKIP];
-	struct v4l2_ctrl *tol_min = fim->ctrl[FIM_CL_TOLERANCE_MIN];
-	struct v4l2_ctrl *tol_max = fim->ctrl[FIM_CL_TOLERANCE_MAX];
 
 	if (curval) {
-		fim->enabled = en->cur.val;
 		fim->icap_flags = icap_edge->cur.val;
 		fim->icap_channel = icap_chan->cur.val;
-		fim->num_avg = num->cur.val;
-		fim->num_skip = skip->cur.val;
-		fim->tolerance_min = tol_min->cur.val;
-		fim->tolerance_max = tol_max->cur.val;
 	} else {
-		fim->enabled = en->val;
 		fim->icap_flags = icap_edge->val;
 		fim->icap_channel = icap_chan->val;
-		fim->num_avg = num->val;
-		fim->num_skip = skip->val;
-		fim->tolerance_min = tol_min->val;
-		fim->tolerance_max = tol_max->val;
 	}
 
-	/* disable tolerance range if max <= min */
-	if (fim->tolerance_max <= fim->tolerance_min)
-		fim->tolerance_max = 0;
-
-	/* num_skip must be >= 1 if input capture not used */
-	if (!icap_enabled(fim))
-		fim->num_skip = max_t(int, fim->num_skip, 1);
-
-	fim->counter = -fim->num_skip;
-	fim->sum = 0;
+	return icap_enabled(fim);
 }
 
-static void send_fim_event(struct imx_media_fim *fim, unsigned long error)
-{
-	static const struct v4l2_event ev = {
-		.type = V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR,
-	};
-
-	v4l2_subdev_notify_event(fim->sd, &ev);
-}
-
-/*
- * Monitor an averaged frame interval. If the average deviates too much
- * from the nominal frame rate, send the frame interval error event. The
- * frame intervals are averaged in order to quiet noise from
- * (presumably random) interrupt latency.
- */
-static void frame_interval_monitor(struct imx_media_fim *fim,
-				   ktime_t timestamp)
-{
-	long long interval, error;
-	unsigned long error_avg;
-	bool send_event = false;
-
-	if (!fim->enabled || ++fim->counter <= 0)
-		goto out_update_ts;
-
-	/* max error is less than l00µs, so use 32-bit division or fail */
-	interval = ktime_to_ns(ktime_sub(timestamp, fim->last_ts));
-	error = abs(interval - NSEC_PER_USEC * (u64)fim->nominal);
-	if (error > U32_MAX)
-		error = U32_MAX;
-	else
-		error = abs((u32)error / NSEC_PER_USEC);
-
-	if (fim->tolerance_max && error >= fim->tolerance_max) {
-		dev_dbg(fim->sd->dev,
-			"FIM: %llu ignored, out of tolerance bounds\n",
-			error);
-		fim->counter--;
-		goto out_update_ts;
-	}
-
-	fim->sum += error;
-
-	if (fim->counter == fim->num_avg) {
-		error_avg = DIV_ROUND_CLOSEST(fim->sum, fim->num_avg);
-
-		if (error_avg > fim->tolerance_min)
-			send_event = true;
-
-		dev_dbg(fim->sd->dev, "FIM: error: %lu usec%s\n",
-			error_avg, send_event ? " (!!!)" : "");
-
-		fim->counter = 0;
-		fim->sum = 0;
-	}
-
-out_update_ts:
-	fim->last_ts = timestamp;
-	if (send_event)
-		send_fim_event(fim, error_avg);
-}
-
-/*
- * In case we are monitoring the first frame interval after streamon
- * (when fim->num_skip = 0), we need a valid fim->last_ts before we
- * can begin. This only applies to the input capture method. It is not
- * possible to accurately measure the first FI after streamon using the
- * EOF method, so fim->num_skip minimum is set to 1 in that case, so this
- * function is a noop when the EOF method is used.
- */
-static void fim_acquire_first_ts(struct imx_media_fim *fim)
+static void imx_fim_wait_first_timestamp(void *priv)
 {
+	struct imx_media_fim *fim = priv;
 	unsigned long ret;
 
-	if (!fim->enabled || fim->num_skip > 0)
-		return;
-
 	ret = wait_for_completion_timeout(
-		&fim->icap_first_event,
-		msecs_to_jiffies(IMX_MEDIA_EOF_TIMEOUT));
+			&fim->icap_first_event,
+			msecs_to_jiffies(IMX_MEDIA_EOF_TIMEOUT));
 	if (ret == 0)
 		v4l2_warn(fim->sd, "wait first icap event timeout\n");
 }
 
-/* FIM Controls */
 static int fim_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-	struct imx_media_fim *fim = container_of(ctrl->handler,
-						 struct imx_media_fim,
-						 ctrl_handler);
-	unsigned long flags;
+	struct imx_media_fim *fim = ctrl->priv;
 	int ret = 0;
 
-	spin_lock_irqsave(&fim->lock, flags);
-
 	switch (ctrl->id) {
-	case V4L2_CID_IMX_FIM_ENABLE:
-		break;
 	case V4L2_CID_IMX_FIM_ICAP_EDGE:
-		if (fim->stream_on)
+		if (v4l2_fim_is_streaming(fim->core))
 			ret = -EBUSY;
 		break;
 	default:
 		ret = -EINVAL;
+		break;
 	}
 
 	if (!ret)
-		reset_fim(fim, false);
+		v4l2_fim_reset(fim->core, false);
 
-	spin_unlock_irqrestore(&fim->lock, flags);
 	return ret;
 }
 
@@ -245,66 +90,13 @@ static const struct v4l2_ctrl_ops fim_ctrl_ops = {
 	.s_ctrl = fim_s_ctrl,
 };
 
-static const struct v4l2_ctrl_config fim_ctrl[] = {
-	[FIM_CL_ENABLE] = {
-		.ops = &fim_ctrl_ops,
-		.id = V4L2_CID_IMX_FIM_ENABLE,
-		.name = "FIM Enable",
-		.type = V4L2_CTRL_TYPE_BOOLEAN,
-		.def = FIM_CL_ENABLE_DEF,
-		.min = 0,
-		.max = 1,
-		.step = 1,
-	},
-	[FIM_CL_NUM] = {
-		.ops = &fim_ctrl_ops,
-		.id = V4L2_CID_IMX_FIM_NUM,
-		.name = "FIM Num Average",
-		.type = V4L2_CTRL_TYPE_INTEGER,
-		.def = FIM_CL_NUM_DEF,
-		.min =  1, /* no averaging */
-		.max = 64, /* average 64 frames */
-		.step = 1,
-	},
-	[FIM_CL_TOLERANCE_MIN] = {
-		.ops = &fim_ctrl_ops,
-		.id = V4L2_CID_IMX_FIM_TOLERANCE_MIN,
-		.name = "FIM Tolerance Min",
-		.type = V4L2_CTRL_TYPE_INTEGER,
-		.def = FIM_CL_TOLERANCE_MIN_DEF,
-		.min =    2,
-		.max =  200,
-		.step =   1,
-	},
-	[FIM_CL_TOLERANCE_MAX] = {
-		.ops = &fim_ctrl_ops,
-		.id = V4L2_CID_IMX_FIM_TOLERANCE_MAX,
-		.name = "FIM Tolerance Max",
-		.type = V4L2_CTRL_TYPE_INTEGER,
-		.def = FIM_CL_TOLERANCE_MAX_DEF,
-		.min =    0,
-		.max =  500,
-		.step =   1,
-	},
-	[FIM_CL_NUM_SKIP] = {
-		.ops = &fim_ctrl_ops,
-		.id = V4L2_CID_IMX_FIM_NUM_SKIP,
-		.name = "FIM Num Skip",
-		.type = V4L2_CTRL_TYPE_INTEGER,
-		.def = FIM_CL_NUM_SKIP_DEF,
-		.min =   0, /* skip no frames */
-		.max = 256, /* skip 256 frames */
-		.step =  1,
-	},
-};
-
 static const struct v4l2_ctrl_config fim_icap_ctrl[] = {
 	[FIM_CL_ICAP_EDGE] = {
 		.ops = &fim_ctrl_ops,
 		.id = V4L2_CID_IMX_FIM_ICAP_EDGE,
 		.name = "FIM Input Capture Edge",
 		.type = V4L2_CTRL_TYPE_INTEGER,
-		.def =  IRQ_TYPE_NONE, /* input capture disabled by default */
+		.def =  IRQ_TYPE_NONE,
 		.min =  IRQ_TYPE_NONE,
 		.max =  IRQ_TYPE_EDGE_BOTH,
 		.step = 1,
@@ -321,108 +113,66 @@ static const struct v4l2_ctrl_config fim_icap_ctrl[] = {
 	},
 };
 
-static int init_fim_controls(struct imx_media_fim *fim)
-{
-	struct v4l2_ctrl_handler *hdlr = &fim->ctrl_handler;
-	int i, ret;
-
-	v4l2_ctrl_handler_init(hdlr, FIM_NUM_CONTROLS + FIM_NUM_ICAP_CONTROLS);
-
-	for (i = 0; i < FIM_NUM_CONTROLS; i++)
-		fim->ctrl[i] = v4l2_ctrl_new_custom(hdlr,
-						    &fim_ctrl[i],
-						    NULL);
-	for (i = 0; i < FIM_NUM_ICAP_CONTROLS; i++)
-		fim->icap_ctrl[i] = v4l2_ctrl_new_custom(hdlr,
-							 &fim_icap_ctrl[i],
-							 NULL);
-	if (hdlr->error) {
-		ret = hdlr->error;
-		goto err_free;
-	}
-
-	v4l2_ctrl_cluster(FIM_NUM_CONTROLS, fim->ctrl);
-	v4l2_ctrl_cluster(FIM_NUM_ICAP_CONTROLS, fim->icap_ctrl);
-
-	return 0;
-err_free:
-	v4l2_ctrl_handler_free(hdlr);
-	return ret;
-}
-
-/*
- * Monitor frame intervals via EOF interrupt. This method is
- * subject to uncertainty errors introduced by interrupt latency.
- *
- * This is a noop if the Input Capture method is being used, since
- * the frame_interval_monitor() is called by the input capture event
- * callback handler in that case.
- */
 void imx_media_fim_eof_monitor(struct imx_media_fim *fim, ktime_t timestamp)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&fim->lock, flags);
-
-	if (!icap_enabled(fim))
-		frame_interval_monitor(fim, timestamp);
-
-	spin_unlock_irqrestore(&fim->lock, flags);
+	v4l2_fim_eof_monitor(fim->core, timestamp);
 }
 
-/* Called by the subdev in its s_stream callback */
 void imx_media_fim_set_stream(struct imx_media_fim *fim,
-			      const struct v4l2_fract *fi,
+			      const struct v4l2_fract *frame_interval,
 			      bool on)
 {
-	unsigned long flags;
-
-	v4l2_ctrl_lock(fim->ctrl[FIM_CL_ENABLE]);
-
-	if (fim->stream_on == on)
-		goto out;
-
-	if (on) {
-		spin_lock_irqsave(&fim->lock, flags);
-		reset_fim(fim, true);
-		update_fim_nominal(fim, fi);
-		spin_unlock_irqrestore(&fim->lock, flags);
-
-		if (icap_enabled(fim))
-			fim_acquire_first_ts(fim);
-	}
-
-	fim->stream_on = on;
-out:
-	v4l2_ctrl_unlock(fim->ctrl[FIM_CL_ENABLE]);
+	v4l2_fim_set_stream(fim->core, frame_interval, on);
 }
 
 int imx_media_fim_add_controls(struct imx_media_fim *fim)
 {
-	/* add the FIM controls to the calling subdev ctrl handler */
 	return v4l2_ctrl_add_handler(fim->sd->ctrl_handler,
 				     &fim->ctrl_handler, NULL, true);
 }
 
-/* Called by the subdev in its subdev registered callback */
 struct imx_media_fim *imx_media_fim_init(struct v4l2_subdev *sd)
 {
+	struct v4l2_fim_config config = {
+		.ctrl_base = V4L2_CID_IMX_FIM_ENABLE,
+		.event_type = V4L2_EVENT_IMX_FRAME_INTERVAL_ERROR,
+		.external_timestamp = imx_fim_external_timestamp,
+		.wait_first_timestamp = imx_fim_wait_first_timestamp,
+	};
 	struct imx_media_fim *fim;
-	int ret;
+	int i, ret;
 
 	fim = devm_kzalloc(sd->dev, sizeof(*fim), GFP_KERNEL);
 	if (!fim)
 		return ERR_PTR(-ENOMEM);
 
 	fim->sd = sd;
+	config.priv = fim;
+
+	v4l2_ctrl_handler_init(&fim->ctrl_handler,
+			       V4L2_FIM_NUM_CONTROLS + FIM_NUM_ICAP_CONTROLS);
+
+	fim->core = v4l2_fim_init(sd, &fim->ctrl_handler, &config);
+	if (IS_ERR(fim->core)) {
+		ret = PTR_ERR(fim->core);
+		goto err_free;
+	}
 
-	spin_lock_init(&fim->lock);
+	for (i = 0; i < FIM_NUM_ICAP_CONTROLS; i++)
+		fim->icap_ctrl[i] = v4l2_ctrl_new_custom(&fim->ctrl_handler,
+							 &fim_icap_ctrl[i], fim);
+	if (fim->ctrl_handler.error) {
+		ret = fim->ctrl_handler.error;
+		goto err_free;
+	}
 
-	ret = init_fim_controls(fim);
-	if (ret)
-		return ERR_PTR(ret);
+	v4l2_ctrl_cluster(FIM_NUM_ICAP_CONTROLS, fim->icap_ctrl);
 
 	return fim;
+
+err_free:
+	v4l2_ctrl_handler_free(&fim->ctrl_handler);
+	return ERR_PTR(ret);
 }
 
 void imx_media_fim_free(struct imx_media_fim *fim)
diff --git a/include/media/v4l2-fim.h b/include/media/v4l2-fim.h
new file mode 100644
index 000000000000..4596d0492676
--- /dev/null
+++ b/include/media/v4l2-fim.h
@@ -0,0 +1,40 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * V4L2 frame interval monitor helpers
+ *
+ * Copyright (c) 2016 Mentor Graphics Inc.
+ */
+
+#ifndef _V4L2_FIM_H
+#define _V4L2_FIM_H
+
+#include <linux/ktime.h>
+#include <linux/types.h>
+
+struct v4l2_ctrl_handler;
+struct v4l2_fract;
+struct v4l2_subdev;
+
+struct v4l2_fim;
+
+#define V4L2_FIM_NUM_CONTROLS	5
+
+struct v4l2_fim_config {
+	u32 ctrl_base;
+	u32 event_type;
+	void *priv;
+	bool (*external_timestamp)(void *priv, bool curval);
+	void (*wait_first_timestamp)(void *priv);
+};
+
+struct v4l2_fim *v4l2_fim_init(struct v4l2_subdev *sd,
+			       struct v4l2_ctrl_handler *hdlr,
+			       const struct v4l2_fim_config *config);
+void v4l2_fim_reset(struct v4l2_fim *fim, bool curval);
+void v4l2_fim_set_stream(struct v4l2_fim *fim,
+			 const struct v4l2_fract *frame_interval, bool on);
+void v4l2_fim_eof_monitor(struct v4l2_fim *fim, ktime_t timestamp);
+void v4l2_fim_monitor_timestamp(struct v4l2_fim *fim, ktime_t timestamp);
+bool v4l2_fim_is_streaming(struct v4l2_fim *fim);
+
+#endif
-- 
2.53.0


  parent reply	other threads:[~2026-11-21 14:14 UTC|newest]

Thread overview: 4+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-21 14:14 [PATCH 0/3] media: imx: staging cleanup and FIM export to v4l2-core Jiaqi Shi
2026-11-21 14:14 ` [PATCH 1/3] media: imx: remove legacy video node control and format handling Jiaqi Shi
2026-11-21 14:14 ` Jiaqi Shi [this message]
2026-11-21 14:14 ` [PATCH 3/3] media: imx: allow setting FIM input capture channel Jiaqi Shi

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261121141412.319802-3-shijiaqi_develop@163.com \
    --to=shijiaqi_develop@163.com \
    --cc=Frank.Li@nxp.com \
    --cc=festevam@gmail.com \
    --cc=gregkh@linuxfoundation.org \
    --cc=imx@lists.linux.dev \
    --cc=kernel@pengutronix.de \
    --cc=linux-media@vger.kernel.org \
    --cc=linux-staging@lists.linux.dev \
    --cc=mchehab@kernel.org \
    --cc=p.zabel@pengutronix.de \
    --cc=slongerbeam@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.