Skip to contentSkip to conversation

Fix OV02C10 camera stability on Snapdragon X Elite

PATCH New Saikiran 3 participants 8 messages Jan 24 – Jan 26

Subsystems (6)
lore
Share & tools
lore

Saikiran

author
#0 lore raw

cover Fix OV02C10 camera stability on Snapdragon X Elite

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

author
#1 lore raw

PATCH 1/1 media: qcom: camss: Fix pipeline lock leak in stop_streaming

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)

---
 drivers/media/platform/qcom/camss/camss-video.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)
drivers/media/platform/qcom/camss/camss-video.c +9 -4
index 831486e14754..578c0ae3d997 100644
@@ -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);
Signature · 1 line
2.51.0
maintainer
#2 lore raw

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

Quoted 33 lines · 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.

Quoted 5 lines

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")
Quoted 17 lines

Tested-on: Lenovo Yoga Slim 7x (Snapdragon X Elite, ov02c10 camera)

---
  drivers/media/platform/qcom/camss/camss-video.c | 13 +++++++++----
  1 file changed, 9 insertions(+), 4 deletions(-)
drivers/media/platform/qcom/camss/camss-video.c +0 -3
index 831486e14754..578c0ae3d997 100644
@@ -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;

drivers/media/platform/qcom/camss/camss-video.c static void video_stop_streaming(struct vb2_queue *q) · line 323

Quoted 10 lines
drivers/media/platform/qcom/camss/camss-video.c +9 -1
-		}
+		/*
+		 * 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
}

drivers/media/platform/qcom/camss/camss-video.c static void video_stop_streaming(struct vb2_queue *q) · line 326

Quoted 3 lines
drivers/media/platform/qcom/camss/camss-video.c +0 -0
  	}
 
  	video_device_pipeline_stop(vdev);

---
bod

author
#3 lore raw

PATCH 1/1 media: i2c: ov02c10: Check for errors in disable_streams

In reply to 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")

---
 drivers/media/i2c/ov02c10.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)
drivers/media/i2c/ov02c10.c +11 -1
index b86cae3d2b74..db191dccff75 100644
@@ -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;
 }
 
Signature · 1 line
2.51.0
maintainer
#4 lore raw

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

Quoted 8 lines · 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.

Should we return 0 when disable_streams fails ?

I think the argument for the pm_runtime_put makes some sense.

Quoted 6 lines

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

Quoted 6 lines

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")

Needs.

- Fixes:
- Cc: [email protected]

See: Documentation/process/submitting-patches.rst

Quoted 17 lines
---
  drivers/media/i2c/ov02c10.c | 12 +++++++++++-
  1 file changed, 11 insertions(+), 1 deletion(-)
drivers/media/i2c/ov02c10.c +5 -0
index b86cae3d2b74..db191dccff75 100644
@@ -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);

drivers/media/i2c/ov02c10.c static int ov02c10_disable_streams(struct v4l2_subdev *sd, · line 645

Quoted 10 lines
drivers/media/i2c/ov02c10.c +6 -1
 
-	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.

Quoted 3 lines
drivers/media/i2c/ov02c10.c +0 -0
  	return 0;
  }
 
maintainer
#5 lore raw

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

In reply to Saikiran

Hi,

Quoted 29 lines · 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")

---
 drivers/media/i2c/ov02c10.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)
drivers/media/i2c/ov02c10.c +0 -0
index b86cae3d2b74..db191dccff75 100644

drivers/media/i2c/ov02c10.c static int ov02c10_disable_streams(struct v4l2_subdev *sd, · line 633

Quoted 10 lines
drivers/media/i2c/ov02c10.c +5 -1
@@ -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.

drivers/media/i2c/ov02c10.c static int ov02c10_disable_streams(struct v4l2_subdev *sd, · line 645

Quoted 8 lines
drivers/media/i2c/ov02c10.c +6 -0
 	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

author
#6 lore raw

PATCH 1/1 media: i2c: ov02c10: Enforce cool-down period to prevent brownout

In reply to 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.

---
 drivers/media/i2c/ov02c10.c | 63 +++++++++++++++++++++++++++++++------
 1 file changed, 54 insertions(+), 9 deletions(-)
drivers/media/i2c/ov02c10.c +54 -9
index db191dccff75..7e9454e8540c 100644
@@ -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;
Signature · 1 line
2.51.0
maintainer
#7 lore raw

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

Quoted 10 lines · 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.

Quoted 6 lines

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:

drivers/media/i2c/ov02c10.c +11 -0
index cf93d36032e14..ab68fc3a971f8 100644
@@ -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);
        }
 
Quoted 132 lines

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.

---
  drivers/media/i2c/ov02c10.c | 63 +++++++++++++++++++++++++++++++------
  1 file changed, 54 insertions(+), 9 deletions(-)
drivers/media/i2c/ov02c10.c +54 -9
index db191dccff75..7e9454e8540c 100644
@@ -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;