diff --git a/src/ipa/libipa/agc_mean_luminance.cpp b/src/ipa/libipa/agc_mean_luminance.cpp
index 0c5ad469ae0e..33d938cc6a87 100644
--- a/src/ipa/libipa/agc_mean_luminance.cpp
+++ b/src/ipa/libipa/agc_mean_luminance.cpp
@@ -370,6 +370,7 @@ int parseExposureModes(AgcMeanLuminance::Configuration &config, const ValueNode
 				stages.push_back({
 					.exposureTime = std::chrono::microseconds(exposureTimes[i]),
 					.gain = gains[i],
+					.digitalGain = 1.0,
 				});
 			}
 
@@ -501,6 +502,7 @@ AgcMeanLuminance::AgcMeanLuminance(Configuration &&config)
 				{
 					.exposureTime = utils::Duration::max(),
 					.gain = std::numeric_limits<double>::max(),
+					.digitalGain = 1.0,
 				},
 			});
 }
@@ -543,7 +545,8 @@ void AgcMeanLuminance::setLimits(utils::Duration minExposureTime,
 				 std::vector<AgcMeanLuminance::AgcConstraint> constraints)
 {
 	for (auto &[id, helper] : exposureModeHelpers_)
-		helper.setLimits(minExposureTime, maxExposureTime, minGain, maxGain);
+		helper.setLimits(minExposureTime, maxExposureTime, minGain,
+				 maxGain, 1.0, 1.0);
 
 	additionalConstraints_ = std::move(constraints);
 }
diff --git a/src/ipa/libipa/exposure_mode_helper.cpp b/src/ipa/libipa/exposure_mode_helper.cpp
index 5c4242519bc1..e3a7d096aea6 100644
--- a/src/ipa/libipa/exposure_mode_helper.cpp
+++ b/src/ipa/libipa/exposure_mode_helper.cpp
@@ -82,7 +82,8 @@ namespace ipa {
  */
 ExposureModeHelper::ExposureModeHelper(std::vector<Stage> &&stages)
 	: stages_(std::move(stages)), lineDuration_(1us), minExposureTime_(0us),
-	  maxExposureTime_(0us), minGain_(0), maxGain_(0), sensorHelper_(nullptr)
+	  maxExposureTime_(0us), minGain_(0), maxGain_(0), minDigitalGain_(1.0),
+	  maxDigitalGain_(1.0), sensorHelper_(nullptr)
 {
 	ASSERT(!stages_.empty());
 }
@@ -115,24 +116,29 @@ void ExposureModeHelper::configure(utils::Duration lineDuration,
  * \param[in] maxExposureTime The maximum exposure time supported
  * \param[in] minGain The minimum analogue gain supported
  * \param[in] maxGain The maximum analogue gain supported
+ * \param[in] minDigitalGain The minimum digital gain supported
+ * \param[in] maxDigitalGain The maximum digital gain supported
  *
- * This function configures the exposure time and analogue gain limits that need
- * to be adhered to as the helper divides up exposure. Note that this function
- * *must* be called whenever those limits change and before splitExposure() is
- * used.
+ * This function configures the exposure time, analogue gain and digital gain
+ * limits that need to be adhered to as the helper divides up exposure. Note
+ * that this function *must* be called whenever those limits change and before
+ * splitExposure() is used.
  *
- * If the algorithm using the helpers needs to indicate that either exposure time
- * or analogue gain or both should be fixed it can do so by setting both the
- * minima and maxima to the same value.
+ * If the algorithm using the helpers needs to indicate that exposure time,
+ * analogue gain or digital gain should be fixed it can do so by setting the
+ * minimum and maximum to the same value.
  */
 void ExposureModeHelper::setLimits(utils::Duration minExposureTime,
 				   utils::Duration maxExposureTime,
-				   double minGain, double maxGain)
+				   double minGain, double maxGain,
+				   double minDigitalGain, double maxDigitalGain)
 {
 	minExposureTime_ = minExposureTime;
 	maxExposureTime_ = maxExposureTime;
 	minGain_ = minGain;
 	maxGain_ = maxGain;
+	minDigitalGain_ = minDigitalGain;
+	maxDigitalGain_ = maxDigitalGain;
 }
 
 utils::Duration ExposureModeHelper::clampExposureTime(utils::Duration exposureTime,
@@ -161,6 +167,11 @@ double ExposureModeHelper::clampGain(double gain, double *quantizationGain) cons
 	return clamped;
 }
 
+double ExposureModeHelper::clampDigitalGain(double gain) const
+{
+	return std::clamp(gain, minDigitalGain_, maxDigitalGain_);
+}
+
 /**
  * \struct ExposureModeHelper::Result
  * \brief Result of splitExposure()
@@ -226,29 +237,32 @@ ExposureModeHelper::splitExposure(utils::Duration exposure) const
 	double gain;
 	double quantGain;
 	double quantGain2;
-	bool gainFixed = minGain_ == maxGain_;
-	bool exposureTimeFixed = minExposureTime_ == maxExposureTime_;
+	double digitalGain;
 
 	/*
-	 * There's no point entering the loop if we cannot change either gain
-	 * nor exposure time anyway.
+	 * There's no point entering the loop if we cannot change anything.
 	 */
-	if (exposureTimeFixed && gainFixed) {
+	if (minExposureTime_ == maxExposureTime_ &&
+	    minGain_ == maxGain_ &&
+	    minDigitalGain_ == maxDigitalGain_) {
 		exposureTime = clampExposureTime(minExposureTime_, &quantGain);
 		gain = clampGain(minGain_, &quantGain2);
 		quantGain *= quantGain2;
+		digitalGain = clampDigitalGain(minDigitalGain_);
 
-		return { exposureTime, gain, quantGain,
-			 exposure / (exposureTime * gain * quantGain) };
+		return { exposureTime, gain, quantGain, digitalGain };
 	}
 
 	utils::Duration stageExposureTime = {};
 	double lastStageGain = clampGain(1.0);
+	double lastStageDigitalGain = clampDigitalGain(1.0);
 	double stageGain = {};
+	double stageDigitalGain = {};
 
 	for (const auto &stage : stages_) {
 		stageExposureTime = clampExposureTime(stage.exposureTime, &quantGain);
 		stageGain = clampGain(stage.gain, &quantGain2);
+		stageDigitalGain = clampDigitalGain(stage.digitalGain);
 
 		/*
 		 * We perform the clamping on both exposure time and gain in
@@ -259,26 +273,48 @@ ExposureModeHelper::splitExposure(utils::Duration exposure) const
 		 */
 
 		/* Clamp the gain to lastStageGain and regulate exposureTime. */
-		if (stageExposureTime * lastStageGain >= exposure) {
-			exposureTime = clampExposureTime(exposure / lastStageGain, &quantGain);
-			gain = clampGain(exposure / exposureTime, &quantGain2);
+		if (stageExposureTime * lastStageGain * lastStageDigitalGain >= exposure) {
+			auto targetExposure = exposure / (lastStageGain * lastStageDigitalGain);
+			exposureTime = clampExposureTime(targetExposure, &quantGain);
+
+			auto targetGain = exposure / (exposureTime * lastStageDigitalGain);
+			gain = clampGain(targetGain, &quantGain2);
 			quantGain *= quantGain2;
 
-			return { exposureTime, gain, quantGain,
-				 exposure / (exposureTime * gain * quantGain) };
+			auto targetDigitalGain = exposure / (exposureTime * gain * quantGain);
+			digitalGain = clampDigitalGain(targetDigitalGain);
+
+			return { exposureTime, gain, quantGain, digitalGain };
 		}
 
 		/* Clamp the exposureTime to stageExposureTime and regulate gain. */
-		if (stageExposureTime * stageGain >= exposure) {
+		if (stageExposureTime * stageGain * lastStageDigitalGain >= exposure) {
 			exposureTime = stageExposureTime;
-			gain = clampGain(exposure / exposureTime, &quantGain2);
+
+			auto targetGain = exposure / (exposureTime * lastStageDigitalGain);
+			gain = clampGain(targetGain, &quantGain2);
 			quantGain *= quantGain2;
 
-			return { exposureTime, gain, quantGain,
-				 exposure / (exposureTime * gain * quantGain) };
+			auto targetDigitalGain = exposure / (exposureTime * gain * quantGain);
+			digitalGain = clampDigitalGain(targetDigitalGain);
+
+			return { exposureTime, gain, quantGain, digitalGain };
+		}
+
+		/* Clamp the exposureTime to stageExposureTime and regulate gain. */
+		if (stageExposureTime * stageGain * stageDigitalGain >= exposure) {
+			exposureTime = stageExposureTime;
+			gain = stageGain;
+			quantGain *= quantGain2;
+
+			auto targetDigitalGain = exposure / (exposureTime * gain * quantGain);
+			digitalGain = clampDigitalGain(targetDigitalGain);
+
+			return { exposureTime, gain, quantGain, targetDigitalGain };
 		}
 
 		lastStageGain = stageGain;
+		lastStageDigitalGain = stageDigitalGain;
 	}
 
 	/*
@@ -288,9 +324,9 @@ ExposureModeHelper::splitExposure(utils::Duration exposure) const
 	exposureTime = stageExposureTime;
 	gain = stageGain;
 	quantGain *= quantGain2;
+	digitalGain = stageDigitalGain;
 
-	return { exposureTime, gain, quantGain,
-		 exposure / (exposureTime * gain * quantGain) };
+	return { exposureTime, gain, quantGain, digitalGain };
 }
 
 } /* namespace ipa */
diff --git a/src/ipa/libipa/exposure_mode_helper.h b/src/ipa/libipa/exposure_mode_helper.h
index d33a0fd822e4..aeae5a9cb700 100644
--- a/src/ipa/libipa/exposure_mode_helper.h
+++ b/src/ipa/libipa/exposure_mode_helper.h
@@ -23,14 +23,15 @@ public:
 	struct Stage {
 		utils::Duration exposureTime;
 		double gain;
+		double digitalGain;
 	};
 
 	ExposureModeHelper(std::vector<Stage> &&stages);
 
 	void configure(utils::Duration lineLength, const CameraSensorHelper *sensorHelper);
 	void setLimits(utils::Duration minExposureTime, utils::Duration maxExposureTime,
-		       double minGain, double maxGain);
-
+		       double minGain, double maxGain, double minDigitalGain,
+		       double maxDigitalGain);
 	struct Result {
 		utils::Duration exposureTime;
 		double analogueGain;
@@ -44,6 +45,7 @@ private:
 	utils::Duration clampExposureTime(utils::Duration exposureTime,
 					  double *quantizationGain = nullptr) const;
 	double clampGain(double gain, double *quantizationGain = nullptr) const;
+	double clampDigitalGain(double gain) const;
 
 	std::vector<Stage> stages_;
 
@@ -52,6 +54,8 @@ private:
 	utils::Duration maxExposureTime_;
 	double minGain_;
 	double maxGain_;
+	double minDigitalGain_;
+	double maxDigitalGain_;
 	const CameraSensorHelper *sensorHelper_;
 };
 
