[PATCH 0/3] Fix OV02C10 camera stability on Snapdragon X Elite

[PATCH 0/3] Fix OV02C10 camera stability on Snapdragon X Elite

[Saikiran]

This patch series fixes critical stability issues with the OV02C10 camera
sensor on Snapdragon X Elite platforms, specifically tested on the Lenovo
Yoga Slim 7x (x1e80100).

Problems addressed:
===================

1. Camera pipeline permanently locked after application closes
   - Affects qcom-camss driver
   - Caused by early return in video_stop_streaming() on subdev errors
   - Result: Camera unusable until reboot

2. Silent failure in sensor disable path
   - Affects ov02c10 driver
   - I2C write errors during stream stop are silently ignored
   - Hinders debugging of power management issues

3. Brownout/latch-up from rapid power cycling
   - Affects ov02c10 driver
   - Occurs during browser WebRTC permission flows (rapid open/close/open)
   - Sensor microcontroller locks up requiring full system reboot
   - Root cause: Incomplete regulator discharge between power cycles

Without these fixes, the camera becomes permanently unusable after rapid
open/close cycles and requires a full system reboot to recover.

Testing:
========

All patches tested together on Linux 6.19-rc5 with:
- 50+ camera open/close/open rapid cycles (< 100ms between operations)
- Browser WebRTC permission flows (Chrome, Firefox, Brave)
- qcam stress testing
- libcamera/pipewire integration testing

Hardware tested:
- Lenovo Yoga Slim 7x (Snapdragon X Elite x1e80100)
- OmniVision OV02C10 2MP RGB camera sensor

Ubuntu bug tracking:
https://bugs.launchpad.net/ubuntu/+source/linux/+bug/2138756

Patch overview:
===============

Patch 1: Fix qcom-camss pipeline lock leak
  - Ensures pipeline is always released even when subdevices fail to stop
  - Prevents permanent camera lockup
  - Improves error messages to identify failing subdevice

Patch 2: Add error logging to ov02c10 disable_streams
  - Captures and logs I2C write failures during stream stop
  - Still returns 0 to prevent pipeline lock leaks
  - Aids in debugging power management issues

Patch 3: Enforce 2-second power cycle cool-down in ov02c10
  - Tracks last power-off timestamp
  - Enforces minimum 2-second gap between power cycles
  - Tested delays: 900ms (failed), 1500ms (failed), 2000ms (reliable)
  - Improves power sequencing (MCLK off before regulators)
  - Zero performance penalty for normal usage (camera opened after >2s)

Impact:
=======

These patches resolve a critical user-facing issue where the camera becomes
completely unusable and requires a full system reboot to recover. This
commonly occurs during:
- Browser WebRTC permission prompts
- Video conferencing application startup
- Rapid application switching
- Camera application crashes with immediate restart

The fixes are conservative, well-tested, and maintain backward compatibility
while significantly improving system stability.

Saikiran (3):
  media: qcom: camss: Fix pipeline lock leak in stop_streaming
  media: i2c: ov02c10: Check for errors in disable_streams
  media: i2c: ov02c10: Enforce cool-down period to prevent brownout

 drivers/media/i2c/ov02c10.c                     | 75 +++++++++++++++++----
 drivers/media/platform/qcom/camss/camss-video.c | 13 ++--
 2 files changed, 74 insertions(+), 14 deletions(-)

--
2.51.0

[PATCH] media: qcom: camss: Fix pipeline lock leak in stop_streaming

[Saikiran]

When a browser or application closes the camera, if any subdevice fails
to stop streaming, the video_stop_streaming() function returns early
without calling video_device_pipeline_stop(). This leaves the media
pipeline permanently locked, preventing any other application from
accessing the camera until reboot.

Symptom:
--------
1. Open camera in browser (via pipewire/libcamera)
2. Close browser
3. Try to open camera in another app (e.g., qcam)
4. Error: "Pipeline handler in use by another process"
5. Camera remains locked until reboot

Root Cause:
-----------
In video_stop_streaming() at line 315-318:

  ret = v4l2_subdev_call(subdev, video, s_stream, 0);
  if (ret) {
      dev_err(...);
      return;  // ❌ Early return without pipeline_stop()
  }

This skips the critical cleanup at line 321:
  video_device_pipeline_stop(vdev);

Solution:
---------
Continue stopping all subdevices even if one fails, and ALWAYS call
video_device_pipeline_stop() to release the pipeline lock. This
ensures proper cleanup even in error cases.

The pipeline MUST be released when streaming stops, regardless of
whether individual subdevices report errors. Failing to do so creates
a permanent resource leak that can only be fixed by rebooting.

Fixes: Camera permanently locked after browser closes
Tested-on: Lenovo Yoga Slim 7x (Snapdragon X Elite, ov02c10 camera)
Signed-off-by: Saikiran <bjsaikiran@gmail.com>
---
 drivers/media/platform/qcom/camss/camss-video.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/drivers/media/platform/qcom/camss/camss-video.c b/drivers/media/platform/qcom/camss/camss-video.c
index 831486e14754..578c0ae3d997 100644
--- a/drivers/media/platform/qcom/camss/camss-video.c
+++ b/drivers/media/platform/qcom/camss/camss-video.c
@@ -312,10 +312,15 @@ static void video_stop_streaming(struct vb2_queue *q)
 
 		ret = v4l2_subdev_call(subdev, video, s_stream, 0);
 
-		if (ret) {
-			dev_err(video->camss->dev, "Video pipeline stop failed: %d\n", ret);
-			return;
-		}
+		/*
+		 * Don't return early on error - we must continue to stop
+		 * remaining subdevices and release the pipeline lock to
+		 * prevent the camera from being permanently locked.
+		 */
+		if (ret)
+			dev_err(video->camss->dev,
+				"Failed to stop subdev '%s': %d\n",
+				subdev->name, ret);
 	}
 
 	video_device_pipeline_stop(vdev);
-- 
2.51.0

Re: [PATCH] media: qcom: camss: Fix pipeline lock leak in stop_streaming

[Bryan O'Donoghue]

On 24/01/2026 07:17, Saikiran wrote:
> When a browser or application closes the camera, if any subdevice fails
> to stop streaming, the video_stop_streaming() function returns early
> without calling video_device_pipeline_stop(). This leaves the media
> pipeline permanently locked, preventing any other application from
> accessing the camera until reboot.
> 
> Symptom:
> --------
> 1. Open camera in browser (via pipewire/libcamera)
> 2. Close browser
> 3. Try to open camera in another app (e.g., qcam)
> 4. Error: "Pipeline handler in use by another process"
> 5. Camera remains locked until reboot
> 
> Root Cause:
> -----------
> In video_stop_streaming() at line 315-318:
> 
>    ret = v4l2_subdev_call(subdev, video, s_stream, 0);
>    if (ret) {
>        dev_err(...);
>        return;  // ❌ Early return without pipeline_stop()
>    }
> 
> This skips the critical cleanup at line 321:
>    video_device_pipeline_stop(vdev);
> 
> Solution:
> ---------
> Continue stopping all subdevices even if one fails, and ALWAYS call
> video_device_pipeline_stop() to release the pipeline lock. This
> ensures proper cleanup even in error cases.
> 
> The pipeline MUST be released when streaming stops, regardless of
> whether individual subdevices report errors. Failing to do so creates
> a permanent resource leak that can only be fixed by rebooting.
> 
> Fixes: Camera permanently locked after browser closes

You need to fix your Fixes: tag

Something like:

Fixes: 89013969e232 ("media: camss: sm8250: Pipeline starting and 
stopping for multiple virtual channels")

> Tested-on: Lenovo Yoga Slim 7x (Snapdragon X Elite, ov02c10 camera)
> Signed-off-by: Saikiran <bjsaikiran@gmail.com>
> ---
>   drivers/media/platform/qcom/camss/camss-video.c | 13 +++++++++----
>   1 file changed, 9 insertions(+), 4 deletions(-)
> 
> diff --git a/drivers/media/platform/qcom/camss/camss-video.c b/drivers/media/platform/qcom/camss/camss-video.c
> index 831486e14754..578c0ae3d997 100644
> --- a/drivers/media/platform/qcom/camss/camss-video.c
> +++ b/drivers/media/platform/qcom/camss/camss-video.c
> @@ -312,10 +312,15 @@ static void video_stop_streaming(struct vb2_queue *q)
>   
>   		ret = v4l2_subdev_call(subdev, video, s_stream, 0);
>   
> -		if (ret) {
> -			dev_err(video->camss->dev, "Video pipeline stop failed: %d\n", ret);
> -			return;
> -		}
> +		/*
> +		 * Don't return early on error - we must continue to stop
> +		 * remaining subdevices and release the pipeline lock to
> +		 * prevent the camera from being permanently locked.
> +		 */
> +		if (ret)
> +			dev_err(video->camss->dev,
> +				"Failed to stop subdev '%s': %d\n",
> +				subdev->name, ret);

if (ret) {
	// do stuff here
}

>   	}
>   
>   	video_device_pipeline_stop(vdev);

---
bod

[PATCH] media: i2c: ov02c10: Check for errors in disable_streams

[Saikiran]

The ov02c10_disable_streams() function ignores the return value from
cci_write() when stopping the sensor. If the I2C write fails (e.g.,
due to CCI timeout, power management race, or device removal), the
error is silently lost.

While we still need to return 0 and call pm_runtime_put() regardless
of hardware state (to prevent PM reference leaks and pipeline lock
issues), we should at least log when the hardware stop fails.

This change:
1. Captures the cci_write() return value
2. Logs an error if the write fails
3. Still returns 0 to ensure proper cleanup

Returning an error from disable_streams would cause the camss driver's
video_stop_streaming() to exit early without releasing the pipeline
lock, permanently locking the camera (see commit 044f54e7c).

Related-to: commit 7673f757858c ("media: i2c: ov02c10: Fix race condition in remove and relax reset timings")
Signed-off-by: Saikiran <bjsaikiran@gmail.com>
---
 drivers/media/i2c/ov02c10.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
index b86cae3d2b74..db191dccff75 100644
--- a/drivers/media/i2c/ov02c10.c
+++ b/drivers/media/i2c/ov02c10.c
@@ -629,10 +629,20 @@ static int ov02c10_disable_streams(struct v4l2_subdev *sd,
 				   u32 pad, u64 streams_mask)
 {
 	struct ov02c10 *ov02c10 = to_ov02c10(sd);
+	int ret;
+
+	ret = cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);
+	if (ret)
+		dev_err(ov02c10->dev, "failed to stop streaming: %d\n", ret);
 
-	cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);
 	pm_runtime_put(ov02c10->dev);
 
+	/*
+	 * Return 0 even if cci_write failed. The stream is being stopped,
+	 * so we must release the PM runtime reference regardless of hardware
+	 * state. Returning an error here would cause pipeline lock leaks in
+	 * the camss driver.
+	 */
 	return 0;
 }
 
-- 
2.51.0

Re: [PATCH] media: i2c: ov02c10: Check for errors in disable_streams

[Bryan O'Donoghue]

On 24/01/2026 07:17, Saikiran wrote:
> The ov02c10_disable_streams() function ignores the return value from
> cci_write() when stopping the sensor. If the I2C write fails (e.g.,
> due to CCI timeout, power management race, or device removal), the
> error is silently lost.
> 
> While we still need to return 0 and call pm_runtime_put() regardless
> of hardware state (to prevent PM reference leaks and pipeline lock
> issues), we should at least log when the hardware stop fails.

Should we return 0 when disable_streams fails ?

I think the argument for the pm_runtime_put makes some sense.
> 
> This change:
> 1. Captures the cci_write() return value
> 2. Logs an error if the write fails
> 3. Still returns 0 to ensure proper cleanup
> 
> Returning an error from disable_streams would cause the camss driver's
> video_stop_streaming() to exit early without releasing the pipeline
> lock, permanently locking the camera (see commit 044f54e7c).
> 
> Related-to: commit 7673f757858c ("media: i2c: ov02c10: Fix race condition in remove and relax reset timings")
> Signed-off-by: Saikiran <bjsaikiran@gmail.com>

Needs.

- Fixes:
- Cc: stable@vger.kernel.org

See: Documentation/process/submitting-patches.rst

> ---
>   drivers/media/i2c/ov02c10.c | 12 +++++++++++-
>   1 file changed, 11 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
> index b86cae3d2b74..db191dccff75 100644
> --- a/drivers/media/i2c/ov02c10.c
> +++ b/drivers/media/i2c/ov02c10.c
> @@ -629,10 +629,20 @@ static int ov02c10_disable_streams(struct v4l2_subdev *sd,
>   				   u32 pad, u64 streams_mask)
>   {
>   	struct ov02c10 *ov02c10 = to_ov02c10(sd);
> +	int ret;
> +
> +	ret = cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);
> +	if (ret)
> +		dev_err(ov02c10->dev, "failed to stop streaming: %d\n", ret);
>   
> -	cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);
>   	pm_runtime_put(ov02c10->dev);
>   
> +	/*
> +	 * Return 0 even if cci_write failed. The stream is being stopped,
> +	 * so we must release the PM runtime reference regardless of hardware
> +	 * state. Returning an error here would cause pipeline lock leaks in
> +	 * the camss driver.
> +	 */

I don't think the comment is necessary - your commit log will document 
all the detail you need.

>   	return 0;
>   }
>   

Re: [PATCH] media: i2c: ov02c10: Check for errors in disable_streams

[Hans de Goede]

Hi,

On 24-Jan-26 08:17, Saikiran wrote:
> The ov02c10_disable_streams() function ignores the return value from
> cci_write() when stopping the sensor. If the I2C write fails (e.g.,
> due to CCI timeout, power management race, or device removal), the
> error is silently lost.
> 
> While we still need to return 0 and call pm_runtime_put() regardless
> of hardware state (to prevent PM reference leaks and pipeline lock
> issues), we should at least log when the hardware stop fails.
> 
> This change:
> 1. Captures the cci_write() return value
> 2. Logs an error if the write fails
> 3. Still returns 0 to ensure proper cleanup
> 
> Returning an error from disable_streams would cause the camss driver's
> video_stop_streaming() to exit early without releasing the pipeline
> lock, permanently locking the camera (see commit 044f54e7c).
> 
> Related-to: commit 7673f757858c ("media: i2c: ov02c10: Fix race condition in remove and relax reset timings")
> Signed-off-by: Saikiran <bjsaikiran@gmail.com>
> ---
>  drivers/media/i2c/ov02c10.c | 12 +++++++++++-
>  1 file changed, 11 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
> index b86cae3d2b74..db191dccff75 100644
> --- a/drivers/media/i2c/ov02c10.c
> +++ b/drivers/media/i2c/ov02c10.c
> @@ -629,10 +629,20 @@ static int ov02c10_disable_streams(struct v4l2_subdev *sd,
>  				   u32 pad, u64 streams_mask)
>  {
>  	struct ov02c10 *ov02c10 = to_ov02c10(sd);
> +	int ret;
> +
> +	ret = cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);
> +	if (ret)
> +		dev_err(ov02c10->dev, "failed to stop streaming: %d\n", ret);
>  
> -	cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 0, NULL);

cci_write() already logs a message on errors itself, so this is
undesirable as it will lead to duplicate log messages.

>  	pm_runtime_put(ov02c10->dev);
>  
> +	/*
> +	 * Return 0 even if cci_write failed. The stream is being stopped,
> +	 * so we must release the PM runtime reference regardless of hardware
> +	 * state. Returning an error here would cause pipeline lock leaks in
> +	 * the camss driver.
> +	 */

And as Brian stated such a big comment is not really necessary. disable_streams()
always returning 0 is normal and at some point we really ought to just make
its return-type "void".

So neither change is necessary here and this patch should be dropped.

Regards,

Hans

[PATCH] media: i2c: ov02c10: Enforce cool-down period to prevent brownout

[Saikiran]

The OV02C10 sensor is susceptible to brownout/latch-up states when
power-cycled rapidly (e.g., within 50-100ms). This often occurs during
userspace interactions like browser WebRTC permissions checks, where
the device is opened, closed, and reopened in quick succession.

When this happens, the regulator discharge is incomplete, and the
sensor fails to perform a clean Power-On Reset (POR). The internal
microcontroller locks up, resulting in I2C timeouts ("failed to set
mode") and necessitating a full system reboot to recover the camera.

To prevent this, implement a mandatory cool-down period. The driver
now tracks the timestamp of the last power-off. If a power-on attempt
occurs within 3 seconds of the last power-off, the driver sleeps for
the remaining duration to ensure physical power rails have fully
discharged and the sensor has completely reset before voltage is
re-applied.

Additionally, standard Power-On-Reset logic is refined:
1. Ensure MCLK is disabled BEFORE regulators during power-off to
   prevent phantom power injection.
2. Assert the reset line (hold low) throughout the regulator ramp-up
   phase to prevent indeterminate states.

Testing Results (10 rapid cycles each):
1. 900ms minimum gap:  Failed (brownout/timeout errors)
2. 1500ms minimum gap: Failed (intermittent failures)
3. 2000ms minimum gap: Reliable (0 failures in 50+ test cycles)
4. 3000ms minimum gap: Reliable (excessive, 2s is sufficient)

The 3-second check window with 2-second minimum enforcement provides
the optimal balance between reliability and responsiveness.

Signed-off-by: Saikiran <bjsaikiran@gmail.com>
---
 drivers/media/i2c/ov02c10.c | 63 +++++++++++++++++++++++++++++++------
 1 file changed, 54 insertions(+), 9 deletions(-)

diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
index db191dccff75..7e9454e8540c 100644
--- a/drivers/media/i2c/ov02c10.c
+++ b/drivers/media/i2c/ov02c10.c
@@ -389,6 +389,9 @@ struct ov02c10 {
 	/* MIPI lane info */
 	u32 link_freq_index;
 	u8 mipi_lanes;
+
+	/* Power cycling rate limit */
+	ktime_t last_power_off;
 };
 
 static inline struct ov02c10 *to_ov02c10(struct v4l2_subdev *subdev)
@@ -616,6 +619,13 @@ static int ov02c10_enable_streams(struct v4l2_subdev *sd,
 	if (ret)
 		goto out;
 
+	/*
+	 * Delay before streaming:
+	 * Give the sensor time to process all the register writes and internal
+	 * calibration before we assert the STREAM_ON bit.
+	 */
+	usleep_range(2000, 2500);
+
 	ret = cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 1, NULL);
 out:
 	if (ret)
@@ -670,12 +680,25 @@ static int ov02c10_power_off(struct device *dev)
 	struct v4l2_subdev *sd = dev_get_drvdata(dev);
 	struct ov02c10 *ov02c10 = to_ov02c10(sd);
 
+	/* 1. Assert Reset */
 	gpiod_set_value_cansleep(ov02c10->reset, 1);
 
+	/* 2. Disable Clock (Stop sensor state machine) */
+	clk_disable_unprepare(ov02c10->img_clk);
+	usleep_range(1000, 1500);
+
+	/* 3. Disable Power */
 	regulator_bulk_disable(ARRAY_SIZE(ov02c10_supply_names),
 			       ov02c10->supplies);
 
-	clk_disable_unprepare(ov02c10->img_clk);
+	/*
+	 * 4. Discharge Wait
+	 * Wait for regulators to fully discharge before returning.
+	 * This delay ensures clean power cycling.
+	 */
+	usleep_range(50000, 55000);
+
+	ov02c10->last_power_off = ktime_get();
 
 	return 0;
 }
@@ -685,26 +708,48 @@ static int ov02c10_power_on(struct device *dev)
 	struct v4l2_subdev *sd = dev_get_drvdata(dev);
 	struct ov02c10 *ov02c10 = to_ov02c10(sd);
 	int ret;
+	s64 delta_us;
 
-	ret = clk_prepare_enable(ov02c10->img_clk);
-	if (ret < 0) {
-		dev_err(dev, "failed to enable imaging clock: %d", ret);
-		return ret;
+	/*
+	 * Mandatory Cool-Down:
+	 * If the camera was powered off within the last 3 seconds, ensure at least
+	 * 2 seconds have elapsed to allow full regulator discharge and sensor reset.
+	 * This prevents brownouts during rapid open/close/open sequences.
+	 */
+	delta_us = ktime_us_delta(ktime_get(), ov02c10->last_power_off);
+	if (delta_us < 3000000) {
+		dev_dbg(dev, "Enforcing %lld us cool-down period\n", 2000000 - delta_us);
+		fsleep(2000000 - delta_us);
 	}
 
+	/*
+	 * Standard Power-Up Sequence:
+	 * 1. Enable Regulators
+	 * 2. Enable Clock
+	 * 3. Release Reset (with ample boot time)
+	 */
+
 	ret = regulator_bulk_enable(ARRAY_SIZE(ov02c10_supply_names),
 				    ov02c10->supplies);
 	if (ret < 0) {
 		dev_err(dev, "failed to enable regulators: %d", ret);
-		clk_disable_unprepare(ov02c10->img_clk);
 		return ret;
 	}
 
+	ret = clk_prepare_enable(ov02c10->img_clk);
+	if (ret < 0) {
+		dev_err(dev, "failed to enable imaging clock: %d", ret);
+		regulator_bulk_disable(ARRAY_SIZE(ov02c10_supply_names),
+				       ov02c10->supplies);
+		return ret;
+	}
+
+	/* Wait for power/clock to stabilize */
+	usleep_range(5000, 5500);
+
 	if (ov02c10->reset) {
-		/* Assert reset for at least 2ms on back to back off-on */
-		usleep_range(5000, 5500);
 		gpiod_set_value_cansleep(ov02c10->reset, 0);
-		usleep_range(20000, 21000);
+		usleep_range(80000, 85000);
 	}
 
 	return 0;
-- 
2.51.0

Re: [PATCH] media: i2c: ov02c10: Enforce cool-down period to prevent brownout

[Bryan O'Donoghue]

On 24/01/2026 07:17, Saikiran wrote:
> The OV02C10 sensor is susceptible to brownout/latch-up states when
> power-cycled rapidly (e.g., within 50-100ms). This often occurs during
> userspace interactions like browser WebRTC permissions checks, where
> the device is opened, closed, and reopened in quick succession.
> 
> When this happens, the regulator discharge is incomplete, and the
> sensor fails to perform a clean Power-On Reset (POR). The internal
> microcontroller locks up, resulting in I2C timeouts ("failed to set
> mode") and necessitating a full system reboot to recover the camera.
> 
> To prevent this, implement a mandatory cool-down period. The driver
> now tracks the timestamp of the last power-off. If a power-on attempt
> occurs within 3 seconds of the last power-off, the driver sleeps for
> the remaining duration to ensure physical power rails have fully
> discharged and the sensor has completely reset before voltage is
> re-applied.

3 seconds ????????????

This seems completely wrong.

I think we should look at - again - improving/fixing the power_on() 
logic to ensure we

- Put the reset pin into a known state
- Carefully apply clock and power as per chip stipulations
- Try to capture the T timings either with documentation or
   trial and error

That is to say getting the power-on function right should fix this. 
Likely we are going through power_on() incorrectly for one of the 
timings to correctly bring the chip into the right state - or not 
respecting the gap between power-on and first CCI or first stream.

Since this code has mostly been developed used on x86/ACPI systems it is 
entirely plausible that the OSPM agent on x86 does stuff around 
reset/power-on that we don't have in !ACPI world.

Lets take a quick look.

Minimum XVCLK freq is 6 MHz.

t1: XSHUTDN min 5 unit milliseconds
t2: first CCI min 8192 XVCLK cycles
     @ 6MHz this is 1365361 nanoseconds
     1.37 milliseconds
t3: MIPI CLK start time max 8192 XVCLK cycles
t4: First data on MIPI bus - variable
t5: infinite nanoseconds

power_on() {
	- XSHUTDOWN is assumed be be asserted
	- XVCLK is assumed to be freerunning i.e. already started and
	  stable prior to the next step
	- T5: DOVDD, AVDD, DVDD power on = potentially infinite
	  Hardware standby period
	- T2: First CCI
}

stream_on() {
	- T3: Time it take for MIPI MCP/MCN clock to start = 8192 XVCLKs
	- T4: First time to data is variable but, this is irrelevant
}

T3: T3: the time from XSHUTOWN/VDD off to power_off unspecified.

power_off() {
	- XSHUTDOWN
	- T3: hardware standby period
	- VDD shutdown
}

In the code, we don't assert reset in power_on() - so we are reliant on 
power_off(); to have run and completed and that XSHUTDOWN is in the 
logical state we expect.

Try something like:

diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
index cf93d36032e14..ab68fc3a971f8 100644
--- a/drivers/media/i2c/ov02c10.c
+++ b/drivers/media/i2c/ov02c10.c
@@ -661,6 +661,7 @@ static int ov02c10_power_off(struct device *dev)
         struct ov02c10 *ov02c10 = to_ov02c10(sd);

         gpiod_set_value_cansleep(ov02c10->reset, 1);
+       usleep_range(2000, 2200);

         regulator_bulk_disable(ARRAY_SIZE(ov02c10_supply_names),
                                ov02c10->supplies);
@@ -676,12 +677,21 @@ static int ov02c10_power_on(struct device *dev)
         struct ov02c10 *ov02c10 = to_ov02c10(sd);
         int ret;

+       if (ov02c10->reset) {
+               /* Ensure reset is asserted before trying to power_on */
+               gpiod_set_value_cansleep(ov02c10->reset, 1);
+               usleep_range(2000, 2200);
+       }
+
         ret = clk_prepare_enable(ov02c10->img_clk);
         if (ret < 0) {
                 dev_err(dev, "failed to enable imaging clock: %d", ret);
                 return ret;
         }

+       /* Let the clock stabilise */
+       usleep_range(2000, 2200);
+
         ret = regulator_bulk_enable(ARRAY_SIZE(ov02c10_supply_names),
                                     ov02c10->supplies);
         if (ret < 0) {
@@ -694,6 +704,7 @@ static int ov02c10_power_on(struct device *dev)
                 /* Assert reset for at least 2ms on back to back off-on */
                 usleep_range(2000, 2200);
                 gpiod_set_value_cansleep(ov02c10->reset, 0);
+               /* This is where we need to capture power_on() T2 */
                 usleep_range(5000, 5100);
         }

> Additionally, standard Power-On-Reset logic is refined:
> 1. Ensure MCLK is disabled BEFORE regulators during power-off to
>     prevent phantom power injection.
> 2. Assert the reset line (hold low) throughout the regulator ramp-up
>     phase to prevent indeterminate states.
> 
> Testing Results (10 rapid cycles each):
> 1. 900ms minimum gap:  Failed (brownout/timeout errors)
> 2. 1500ms minimum gap: Failed (intermittent failures)
> 3. 2000ms minimum gap: Reliable (0 failures in 50+ test cycles)
> 4. 3000ms minimum gap: Reliable (excessive, 2s is sufficient)
> 
> The 3-second check window with 2-second minimum enforcement provides
> the optimal balance between reliability and responsiveness.
> 
> Signed-off-by: Saikiran <bjsaikiran@gmail.com>
> ---
>   drivers/media/i2c/ov02c10.c | 63 +++++++++++++++++++++++++++++++------
>   1 file changed, 54 insertions(+), 9 deletions(-)
> 
> diff --git a/drivers/media/i2c/ov02c10.c b/drivers/media/i2c/ov02c10.c
> index db191dccff75..7e9454e8540c 100644
> --- a/drivers/media/i2c/ov02c10.c
> +++ b/drivers/media/i2c/ov02c10.c
> @@ -389,6 +389,9 @@ struct ov02c10 {
>   	/* MIPI lane info */
>   	u32 link_freq_index;
>   	u8 mipi_lanes;
> +
> +	/* Power cycling rate limit */
> +	ktime_t last_power_off;
>   };
>   
>   static inline struct ov02c10 *to_ov02c10(struct v4l2_subdev *subdev)
> @@ -616,6 +619,13 @@ static int ov02c10_enable_streams(struct v4l2_subdev *sd,
>   	if (ret)
>   		goto out;
>   
> +	/*
> +	 * Delay before streaming:
> +	 * Give the sensor time to process all the register writes and internal
> +	 * calibration before we assert the STREAM_ON bit.
> +	 */
> +	usleep_range(2000, 2500);
> +
>   	ret = cci_write(ov02c10->regmap, OV02C10_REG_STREAM_CONTROL, 1, NULL);
>   out:
>   	if (ret)
> @@ -670,12 +680,25 @@ static int ov02c10_power_off(struct device *dev)
>   	struct v4l2_subdev *sd = dev_get_drvdata(dev);
>   	struct ov02c10 *ov02c10 = to_ov02c10(sd);
>   
> +	/* 1. Assert Reset */
>   	gpiod_set_value_cansleep(ov02c10->reset, 1);
>   
> +	/* 2. Disable Clock (Stop sensor state machine) */
> +	clk_disable_unprepare(ov02c10->img_clk);
> +	usleep_range(1000, 1500);
> +
> +	/* 3. Disable Power */
>   	regulator_bulk_disable(ARRAY_SIZE(ov02c10_supply_names),
>   			       ov02c10->supplies);
>   
> -	clk_disable_unprepare(ov02c10->img_clk);
> +	/*
> +	 * 4. Discharge Wait
> +	 * Wait for regulators to fully discharge before returning.
> +	 * This delay ensures clean power cycling.
> +	 */
> +	usleep_range(50000, 55000);
> +
> +	ov02c10->last_power_off = ktime_get();
>   
>   	return 0;
>   }
> @@ -685,26 +708,48 @@ static int ov02c10_power_on(struct device *dev)
>   	struct v4l2_subdev *sd = dev_get_drvdata(dev);
>   	struct ov02c10 *ov02c10 = to_ov02c10(sd);
>   	int ret;
> +	s64 delta_us;
>   
> -	ret = clk_prepare_enable(ov02c10->img_clk);
> -	if (ret < 0) {
> -		dev_err(dev, "failed to enable imaging clock: %d", ret);
> -		return ret;
> +	/*
> +	 * Mandatory Cool-Down:
> +	 * If the camera was powered off within the last 3 seconds, ensure at least
> +	 * 2 seconds have elapsed to allow full regulator discharge and sensor reset.
> +	 * This prevents brownouts during rapid open/close/open sequences.
> +	 */
> +	delta_us = ktime_us_delta(ktime_get(), ov02c10->last_power_off);
> +	if (delta_us < 3000000) {
> +		dev_dbg(dev, "Enforcing %lld us cool-down period\n", 2000000 - delta_us);
> +		fsleep(2000000 - delta_us);
>   	}
>   
> +	/*
> +	 * Standard Power-Up Sequence:
> +	 * 1. Enable Regulators
> +	 * 2. Enable Clock
> +	 * 3. Release Reset (with ample boot time)
> +	 */
> +
>   	ret = regulator_bulk_enable(ARRAY_SIZE(ov02c10_supply_names),
>   				    ov02c10->supplies);
>   	if (ret < 0) {
>   		dev_err(dev, "failed to enable regulators: %d", ret);
> -		clk_disable_unprepare(ov02c10->img_clk);
>   		return ret;
>   	}
>   
> +	ret = clk_prepare_enable(ov02c10->img_clk);
> +	if (ret < 0) {
> +		dev_err(dev, "failed to enable imaging clock: %d", ret);
> +		regulator_bulk_disable(ARRAY_SIZE(ov02c10_supply_names),
> +				       ov02c10->supplies);
> +		return ret;
> +	}
> +
> +	/* Wait for power/clock to stabilize */
> +	usleep_range(5000, 5500);
> +
>   	if (ov02c10->reset) {
> -		/* Assert reset for at least 2ms on back to back off-on */
> -		usleep_range(5000, 5500);
>   		gpiod_set_value_cansleep(ov02c10->reset, 0);
> -		usleep_range(20000, 21000);
> +		usleep_range(80000, 85000);
>   	}
>   
>   	return 0;