All of lore.kernel.org
 help / color / mirror / Atom feed
From: Sakari Ailus <sakari.ailus@linux.intel.com>
To: linux-media@vger.kernel.org
Subject: [PATCH 073/100] ccs-pll: Split off VT subtree calculation
Date: Wed, 30 Sep 2020 18:28:31 +0300	[thread overview]
Message-ID: <20200930152858.8471-74-sakari.ailus@linux.intel.com> (raw)
In-Reply-To: <20200930152858.8471-1-sakari.ailus@linux.intel.com>

Split off the VT sub clock tree calculation from the rest, into its own
function. Also call the op_pll_fr argument pll_fr, since soon these may
not be OP tree values.

This paves way for additional features in the future such as dual PLL
support.

Signed-off-by: Sakari Ailus <sakari.ailus@linux.intel.com>
---
 drivers/media/i2c/ccs-pll.c | 255 ++++++++++++++++++------------------
 1 file changed, 131 insertions(+), 124 deletions(-)

diff --git a/drivers/media/i2c/ccs-pll.c b/drivers/media/i2c/ccs-pll.c
index 52e6230c087d..34e372b0bb84 100644
--- a/drivers/media/i2c/ccs-pll.c
+++ b/drivers/media/i2c/ccs-pll.c
@@ -149,130 +149,18 @@ static int check_all_bounds(struct device *dev,
 #define DPHY_CONST		16
 #define PHY_CONST_DIV		16
 
-/*
- * Heuristically guess the PLL tree for a given common multiplier and
- * divisor. Begin with the operational timing and continue to video
- * timing once operational timing has been verified.
- *
- * @mul is the PLL multiplier and @div is the common divisor
- * (pre_pll_clk_div and op_sys_clk_div combined). The final PLL
- * multiplier will be a multiple of @mul.
- *
- * @return Zero on success, error code on error.
- */
-static int
-__ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
-		    const struct ccs_pll_branch_limits_fr *op_lim_fr,
-		    const struct ccs_pll_branch_limits_bk *op_lim_bk,
-		    struct ccs_pll *pll, struct ccs_pll_branch_fr *op_pll_fr,
-		    struct ccs_pll_branch_bk *op_pll_bk, uint32_t mul,
-		    uint32_t div, uint32_t l, bool cphy, uint32_t phy_const)
+static void
+__ccs_pll_calculate_vt(struct device *dev, const struct ccs_pll_limits *lim,
+		       const struct ccs_pll_branch_limits_bk *op_lim_bk,
+		       struct ccs_pll *pll, struct ccs_pll_branch_fr *pll_fr,
+		       struct ccs_pll_branch_bk *op_pll_bk, bool cphy,
+		       uint32_t phy_const)
 {
 	uint32_t sys_div;
 	uint32_t best_pix_div = INT_MAX >> 1;
 	uint32_t vt_op_binning_div;
-	/*
-	 * Higher multipliers (and divisors) are often required than
-	 * necessitated by the external clock and the output clocks.
-	 * There are limits for all values in the clock tree. These
-	 * are the minimum and maximum multiplier for mul.
-	 */
-	uint32_t more_mul_min, more_mul_max;
-	uint32_t more_mul_factor;
 	uint32_t min_vt_div, max_vt_div, vt_div;
 	uint32_t min_sys_div, max_sys_div;
-	uint32_t i;
-
-	/*
-	 * Get pre_pll_clk_div so that our pll_op_clk_freq_hz won't be
-	 * too high.
-	 */
-	dev_dbg(dev, "op_pre_pll_clk_div %u\n", op_pll_fr->pre_pll_clk_div);
-
-	/* Don't go above max pll multiplier. */
-	more_mul_max = op_lim_fr->max_pll_multiplier / mul;
-	dev_dbg(dev, "more_mul_max: max_op_pll_multiplier check: %u\n",
-		more_mul_max);
-	/* Don't go above max pll op frequency. */
-	more_mul_max =
-		min_t(uint32_t,
-		      more_mul_max,
-		      op_lim_fr->max_pll_op_clk_freq_hz
-		      / (pll->ext_clk_freq_hz /
-			 op_pll_fr->pre_pll_clk_div * mul));
-	dev_dbg(dev, "more_mul_max: max_pll_op_clk_freq_hz check: %u\n",
-		more_mul_max);
-	/* Don't go above the division capability of op sys clock divider. */
-	more_mul_max = min(more_mul_max,
-			   op_lim_bk->max_sys_clk_div * op_pll_fr->pre_pll_clk_div
-			   / div);
-	dev_dbg(dev, "more_mul_max: max_op_sys_clk_div check: %u\n",
-		more_mul_max);
-	/* Ensure we won't go above max_pll_multiplier. */
-	more_mul_max = min(more_mul_max, op_lim_fr->max_pll_multiplier / mul);
-	dev_dbg(dev, "more_mul_max: min_pll_multiplier check: %u\n",
-		more_mul_max);
-
-	/* Ensure we won't go below min_pll_op_clk_freq_hz. */
-	more_mul_min = DIV_ROUND_UP(op_lim_fr->min_pll_op_clk_freq_hz,
-				    pll->ext_clk_freq_hz /
-				    op_pll_fr->pre_pll_clk_div * mul);
-	dev_dbg(dev, "more_mul_min: min_op_pll_op_clk_freq_hz check: %u\n",
-		more_mul_min);
-	/* Ensure we won't go below min_pll_multiplier. */
-	more_mul_min = max(more_mul_min,
-			   DIV_ROUND_UP(op_lim_fr->min_pll_multiplier, mul));
-	dev_dbg(dev, "more_mul_min: min_op_pll_multiplier check: %u\n",
-		more_mul_min);
-
-	if (more_mul_min > more_mul_max) {
-		dev_dbg(dev,
-			"unable to compute more_mul_min and more_mul_max\n");
-		return -EINVAL;
-	}
-
-	more_mul_factor = lcm(div, op_pll_fr->pre_pll_clk_div) / div;
-	dev_dbg(dev, "more_mul_factor: %u\n", more_mul_factor);
-	more_mul_factor = lcm(more_mul_factor, op_lim_bk->min_sys_clk_div);
-	dev_dbg(dev, "more_mul_factor: min_op_sys_clk_div: %d\n",
-		more_mul_factor);
-	i = roundup(more_mul_min, more_mul_factor);
-	if (!is_one_or_even(i))
-		i <<= 1;
-
-	dev_dbg(dev, "final more_mul: %u\n", i);
-	if (i > more_mul_max) {
-		dev_dbg(dev, "final more_mul is bad, max %u\n", more_mul_max);
-		return -EINVAL;
-	}
-
-	op_pll_fr->pll_multiplier = mul * i;
-	op_pll_bk->sys_clk_div = div * i / op_pll_fr->pre_pll_clk_div;
-	dev_dbg(dev, "op_sys_clk_div: %u\n", op_pll_bk->sys_clk_div);
-
-	op_pll_fr->pll_ip_clk_freq_hz = pll->ext_clk_freq_hz
-		/ op_pll_fr->pre_pll_clk_div;
-
-	op_pll_fr->pll_op_clk_freq_hz = op_pll_fr->pll_ip_clk_freq_hz
-		* op_pll_fr->pll_multiplier;
-
-	if (pll->flags & CCS_PLL_FLAG_LANE_SPEED_MODEL)
-		op_pll_bk->pix_clk_div = pll->bits_per_pixel
-			* pll->op_lanes * phy_const
-			/ PHY_CONST_DIV / pll->csi2.lanes / l;
-	else
-		op_pll_bk->pix_clk_div =
-			pll->bits_per_pixel * phy_const / PHY_CONST_DIV / l;
-
-	op_pll_bk->pix_clk_freq_hz =
-		op_pll_bk->sys_clk_freq_hz / op_pll_bk->pix_clk_div;
-
-	dev_dbg(dev, "op_pix_clk_div: %u\n", op_pll_bk->pix_clk_div);
-
-	if (pll->flags & CCS_PLL_FLAG_NO_OP_CLOCKS) {
-		/* No OP clocks --- VT clocks are used instead. */
-		goto out_skip_vt_calc;
-	}
 
 	/*
 	 * Some sensors perform analogue binning and some do this
@@ -310,7 +198,7 @@ __ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
 	/* Find smallest and biggest allowed vt divisor. */
 	dev_dbg(dev, "min_vt_div: %u\n", min_vt_div);
 	min_vt_div = max(min_vt_div,
-			 DIV_ROUND_UP(op_pll_fr->pll_op_clk_freq_hz,
+			 DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,
 				      lim->vt_bk.max_pix_clk_freq_hz));
 	dev_dbg(dev, "min_vt_div: max_vt_pix_clk_freq_hz: %u\n",
 		min_vt_div);
@@ -322,7 +210,7 @@ __ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
 	max_vt_div = lim->vt_bk.max_sys_clk_div * lim->vt_bk.max_pix_clk_div;
 	dev_dbg(dev, "max_vt_div: %u\n", max_vt_div);
 	max_vt_div = min(max_vt_div,
-			 DIV_ROUND_UP(op_pll_fr->pll_op_clk_freq_hz,
+			 DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,
 				      lim->vt_bk.min_pix_clk_freq_hz));
 	dev_dbg(dev, "max_vt_div: min_vt_pix_clk_freq_hz: %u\n",
 		max_vt_div);
@@ -338,7 +226,7 @@ __ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
 				       lim->vt_bk.max_pix_clk_div));
 	dev_dbg(dev, "min_sys_div: max_vt_pix_clk_div: %u\n", min_sys_div);
 	min_sys_div = max(min_sys_div,
-			  op_pll_fr->pll_op_clk_freq_hz
+			  pll_fr->pll_op_clk_freq_hz
 			  / lim->vt_bk.max_sys_clk_freq_hz);
 	dev_dbg(dev, "min_sys_div: max_pll_op_clk_freq_hz: %u\n", min_sys_div);
 	min_sys_div = clk_div_even_up(min_sys_div);
@@ -351,7 +239,7 @@ __ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
 				       lim->vt_bk.min_pix_clk_div));
 	dev_dbg(dev, "max_sys_div: min_vt_pix_clk_div: %u\n", max_sys_div);
 	max_sys_div = min(max_sys_div,
-			  DIV_ROUND_UP(op_pll_fr->pll_op_clk_freq_hz,
+			  DIV_ROUND_UP(pll_fr->pll_op_clk_freq_hz,
 				       lim->vt_bk.min_pix_clk_freq_hz));
 	dev_dbg(dev, "max_sys_div: min_vt_pix_clk_freq_hz: %u\n", max_sys_div);
 
@@ -396,11 +284,130 @@ __ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
 	pll->vt_bk.pix_clk_div = best_pix_div;
 
 	pll->vt_bk.sys_clk_freq_hz =
-		op_pll_fr->pll_op_clk_freq_hz / pll->vt_bk.sys_clk_div;
+		pll_fr->pll_op_clk_freq_hz / pll->vt_bk.sys_clk_div;
 	pll->vt_bk.pix_clk_freq_hz =
 		pll->vt_bk.sys_clk_freq_hz / pll->vt_bk.pix_clk_div;
+}
+
+/*
+ * Heuristically guess the PLL tree for a given common multiplier and
+ * divisor. Begin with the operational timing and continue to video
+ * timing once operational timing has been verified.
+ *
+ * @mul is the PLL multiplier and @div is the common divisor
+ * (pre_pll_clk_div and op_sys_clk_div combined). The final PLL
+ * multiplier will be a multiple of @mul.
+ *
+ * @return Zero on success, error code on error.
+ */
+static int
+__ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,
+		    const struct ccs_pll_branch_limits_fr *op_lim_fr,
+		    const struct ccs_pll_branch_limits_bk *op_lim_bk,
+		    struct ccs_pll *pll, struct ccs_pll_branch_fr *op_pll_fr,
+		    struct ccs_pll_branch_bk *op_pll_bk, uint32_t mul,
+		    uint32_t div, uint32_t l, bool cphy, uint32_t phy_const)
+{
+	/*
+	 * Higher multipliers (and divisors) are often required than
+	 * necessitated by the external clock and the output clocks.
+	 * There are limits for all values in the clock tree. These
+	 * are the minimum and maximum multiplier for mul.
+	 */
+	uint32_t more_mul_min, more_mul_max;
+	uint32_t more_mul_factor;
+	uint32_t i;
+
+	/*
+	 * Get pre_pll_clk_div so that our pll_op_clk_freq_hz won't be
+	 * too high.
+	 */
+	dev_dbg(dev, "op_pre_pll_clk_div %u\n", op_pll_fr->pre_pll_clk_div);
+
+	/* Don't go above max pll multiplier. */
+	more_mul_max = op_lim_fr->max_pll_multiplier / mul;
+	dev_dbg(dev, "more_mul_max: max_op_pll_multiplier check: %u\n",
+		more_mul_max);
+	/* Don't go above max pll op frequency. */
+	more_mul_max =
+		min_t(uint32_t,
+		      more_mul_max,
+		      op_lim_fr->max_pll_op_clk_freq_hz
+		      / (pll->ext_clk_freq_hz /
+			 op_pll_fr->pre_pll_clk_div * mul));
+	dev_dbg(dev, "more_mul_max: max_pll_op_clk_freq_hz check: %u\n",
+		more_mul_max);
+	/* Don't go above the division capability of op sys clock divider. */
+	more_mul_max = min(more_mul_max,
+			   op_lim_bk->max_sys_clk_div * op_pll_fr->pre_pll_clk_div
+			   / div);
+	dev_dbg(dev, "more_mul_max: max_op_sys_clk_div check: %u\n",
+		more_mul_max);
+	/* Ensure we won't go above max_pll_multiplier. */
+	more_mul_max = min(more_mul_max, op_lim_fr->max_pll_multiplier / mul);
+	dev_dbg(dev, "more_mul_max: min_pll_multiplier check: %u\n",
+		more_mul_max);
+
+	/* Ensure we won't go below min_pll_op_clk_freq_hz. */
+	more_mul_min = DIV_ROUND_UP(op_lim_fr->min_pll_op_clk_freq_hz,
+				    pll->ext_clk_freq_hz /
+				    op_pll_fr->pre_pll_clk_div * mul);
+	dev_dbg(dev, "more_mul_min: min_op_pll_op_clk_freq_hz check: %u\n",
+		more_mul_min);
+	/* Ensure we won't go below min_pll_multiplier. */
+	more_mul_min = max(more_mul_min,
+			   DIV_ROUND_UP(op_lim_fr->min_pll_multiplier, mul));
+	dev_dbg(dev, "more_mul_min: min_op_pll_multiplier check: %u\n",
+		more_mul_min);
+
+	if (more_mul_min > more_mul_max) {
+		dev_dbg(dev,
+			"unable to compute more_mul_min and more_mul_max\n");
+		return -EINVAL;
+	}
+
+	more_mul_factor = lcm(div, op_pll_fr->pre_pll_clk_div) / div;
+	dev_dbg(dev, "more_mul_factor: %u\n", more_mul_factor);
+	more_mul_factor = lcm(more_mul_factor, op_lim_bk->min_sys_clk_div);
+	dev_dbg(dev, "more_mul_factor: min_op_sys_clk_div: %d\n",
+		more_mul_factor);
+	i = roundup(more_mul_min, more_mul_factor);
+	if (!is_one_or_even(i))
+		i <<= 1;
+
+	dev_dbg(dev, "final more_mul: %u\n", i);
+	if (i > more_mul_max) {
+		dev_dbg(dev, "final more_mul is bad, max %u\n", more_mul_max);
+		return -EINVAL;
+	}
+
+	op_pll_fr->pll_multiplier = mul * i;
+	op_pll_bk->sys_clk_div = div * i / op_pll_fr->pre_pll_clk_div;
+	dev_dbg(dev, "op_sys_clk_div: %u\n", op_pll_bk->sys_clk_div);
+
+	op_pll_fr->pll_ip_clk_freq_hz = pll->ext_clk_freq_hz
+		/ op_pll_fr->pre_pll_clk_div;
+
+	op_pll_fr->pll_op_clk_freq_hz = op_pll_fr->pll_ip_clk_freq_hz
+		* op_pll_fr->pll_multiplier;
+
+	if (pll->flags & CCS_PLL_FLAG_LANE_SPEED_MODEL)
+		op_pll_bk->pix_clk_div = pll->bits_per_pixel
+			* pll->op_lanes * phy_const
+			/ PHY_CONST_DIV / pll->csi2.lanes / l;
+	else
+		op_pll_bk->pix_clk_div =
+			pll->bits_per_pixel * phy_const / PHY_CONST_DIV / l;
+
+	op_pll_bk->pix_clk_freq_hz =
+		op_pll_bk->sys_clk_freq_hz / op_pll_bk->pix_clk_div;
+
+	dev_dbg(dev, "op_pix_clk_div: %u\n", op_pll_bk->pix_clk_div);
+
+	if (!(pll->flags & CCS_PLL_FLAG_NO_OP_CLOCKS))
+		__ccs_pll_calculate_vt(dev, lim, op_lim_bk, pll, op_pll_fr,
+				       op_pll_bk, cphy, phy_const);
 
-out_skip_vt_calc:
 	pll->pixel_rate_pixel_array =
 		pll->vt_bk.pix_clk_freq_hz * pll->vt_lanes;
 
-- 
2.27.0


  parent reply	other threads:[~2020-09-30 15:29 UTC|newest]

Thread overview: 101+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-09-30 15:27 [PATCH 000/100] CCS driver Sakari Ailus
2020-09-30 15:27 ` [PATCH 001/100] smiapp: Add CCS register definitions and limits Sakari Ailus
2020-09-30 15:27 ` [PATCH 002/100] smiapp: Use CCS register flags Sakari Ailus
2020-09-30 15:27 ` [PATCH 003/100] smiapp: Calculate CCS limit offsets and limit buffer size Sakari Ailus
2020-09-30 15:27 ` [PATCH 004/100] smiapp: Remove macros for defining registers, merge definitions Sakari Ailus
2020-09-30 15:27 ` [PATCH 005/100] smiapp: Add macros for accessing CCS registers Sakari Ailus
2020-09-30 15:27 ` [PATCH 006/100] smiapp: Use MIPI CCS version and manufacturer ID information Sakari Ailus
2020-09-30 15:27 ` [PATCH 007/100] smiapp: Read CCS limit values Sakari Ailus
2020-09-30 15:27 ` [PATCH 008/100] smiapp: Switch to CCS limits Sakari Ailus
2020-09-30 15:27 ` [PATCH 009/100] smiapp: Obtain frame descriptor from " Sakari Ailus
2020-09-30 15:27 ` [PATCH 010/100] smiapp: Use CCS limits in reading data format descriptors Sakari Ailus
2020-09-30 15:27 ` [PATCH 011/100] smiapp: Use CCS limits in reading binning capabilities Sakari Ailus
2020-09-30 15:27 ` [PATCH 012/100] smiapp: Use CCS registers Sakari Ailus
2020-09-30 15:27 ` [PATCH 013/100] smiapp: Remove quirk function for writing a single 8-bit register Sakari Ailus
2020-09-30 15:27 ` [PATCH 014/100] smiapp: Rename register access functions Sakari Ailus
2020-09-30 15:27 ` [PATCH 015/100] smiapp: Internal rename to CCS Sakari Ailus
2020-09-30 15:27 ` [PATCH 016/100] smiapp: Differentiate CCS sensors from SMIA in subdev naming Sakari Ailus
2020-09-30 15:27 ` [PATCH 017/100] smiapp: Rename as "ccs" Sakari Ailus
2020-09-30 15:27 ` [PATCH 018/100] ccs: Remove profile concept Sakari Ailus
2020-09-30 15:27 ` [PATCH 019/100] ccs: Give all subdevs a function Sakari Ailus
2020-09-30 15:27 ` [PATCH 020/100] dt-bindings: Add vendor prefix for MIPI Alliance Sakari Ailus
2020-09-30 15:27 ` [PATCH 021/100] dt-bindings: nokia,smia: Fix link-frequencies documentation Sakari Ailus
2020-09-30 15:27 ` [PATCH 022/100] dt-bindings: nokia,smia: Make vana-supply optional Sakari Ailus
2020-09-30 15:27 ` [PATCH 023/100] dt-bindings: nokia,smia: Convert to YAML Sakari Ailus
2020-09-30 15:27 ` [PATCH 024/100] dt-bindings: nokia,smia: Use better active polarity for reset Sakari Ailus
2020-09-30 15:27 ` [PATCH 025/100] dt-bindings: Amend SMIA bindings with MIPI CCS support Sakari Ailus
2020-09-30 15:27 ` [PATCH 026/100] dt-bindings: Add bus-type for C-PHY support Sakari Ailus
2020-09-30 15:27 ` [PATCH 027/100] ccs: Request for "reset" GPIO Sakari Ailus
2020-09-30 15:27 ` [PATCH 028/100] ccs: Add "mipi,ccs" compatible string Sakari Ailus
2020-09-30 15:27 ` [PATCH 029/100] ccs: Remove the I²C ID table Sakari Ailus
2020-09-30 15:27 ` [PATCH 030/100] ccs: Remove remaining support for platform data Sakari Ailus
2020-09-30 15:27 ` [PATCH 031/100] ccs: Make hwcfg part of the device specific struct Sakari Ailus
2020-09-30 15:27 ` [PATCH 032/100] ccs: Add CCS static data parser library Sakari Ailus
2020-09-30 15:27 ` [PATCH 033/100] ccs: Combine revision number major and minor into one Sakari Ailus
2020-09-30 15:27 ` [PATCH 034/100] ccs: Read CCS static data from firmware binaries Sakari Ailus
2020-09-30 15:27 ` [PATCH 035/100] ccs: Stop reading arrays after the first zero Sakari Ailus
2020-09-30 15:27 ` [PATCH 036/100] ccs: The functions to get compose or crop rectangle never return NULL Sakari Ailus
2020-09-30 15:27 ` [PATCH 037/100] ccs: Replace somewhat harsh internal checks based on BUG with WARN_ON Sakari Ailus
2020-09-30 15:27 ` [PATCH 038/100] ccs: Refactor register reading a little Sakari Ailus
2020-09-30 15:27 ` [PATCH 039/100] ccs: Make real to integer number conversion optional Sakari Ailus
2020-09-30 15:27 ` [PATCH 040/100] ccs: Move limit value real to integer conversion from read to access time Sakari Ailus
2020-09-30 15:27 ` [PATCH 041/100] ccs: Read ireal numbers correctly Sakari Ailus
2020-09-30 15:28 ` [PATCH 042/100] smiapp-pll: Rename as ccs-pll Sakari Ailus
2020-09-30 15:28 ` [PATCH 043/100] ccs: Change my e-mail address Sakari Ailus
2020-09-30 15:28 ` [PATCH 044/100] ccs: Add support for manufacturer regs from sensor and module files Sakari Ailus
2020-09-30 15:28 ` [PATCH 045/100] ccs: Use static data read-only registers Sakari Ailus
2020-09-30 15:28 ` [PATCH 046/100] ccs: Clean up runtime PM usage Sakari Ailus
2020-09-30 15:28 ` [PATCH 047/100] ccs: Wrap long lines, unwrap short ones Sakari Ailus
2020-09-30 15:28 ` [PATCH 048/100] ccs: Add device compatible identifiers for telling SMIA and CCS apart Sakari Ailus
2020-09-30 15:28 ` [PATCH 049/100] ccs: Use longer pre-I²C sleep for CCS compliant devices Sakari Ailus
2020-09-30 15:28 ` [PATCH 050/100] ccs-pll: Don't use div_u64 to divide a 32-bit number Sakari Ailus
2020-09-30 15:28 ` [PATCH 051/100] ccs-pll: Split limits and PLL configuration into front and back parts Sakari Ailus
2020-09-30 15:28 ` [PATCH 052/100] ccs-pll: Use correct VT divisor for calculating VT SYS divisor Sakari Ailus
2020-09-30 15:28 ` [PATCH 053/100] ccs-pll: End search if there are no better values available Sakari Ailus
2020-09-30 15:28 ` [PATCH 054/100] ccs-pll: Remove parallel bus support Sakari Ailus
2020-09-30 15:28 ` [PATCH 055/100] ccs-pll: Differentiate between CSI-2 D-PHY and C-PHY Sakari Ailus
2020-09-30 15:28 ` [PATCH 056/100] ccs-pll: Move the flags field down, away from 8-bit fields Sakari Ailus
2020-09-30 15:28 ` [PATCH 057/100] ccs-pll: Document the structs in the header as well as the function Sakari Ailus
2020-09-30 15:28 ` [PATCH 058/100] ccs-pll: Use the BIT macro Sakari Ailus
2020-09-30 15:28 ` [PATCH 059/100] ccs-pll: Begin calculation from OP system clock frequency Sakari Ailus
2020-09-30 15:28 ` [PATCH 060/100] ccs-pll: Fix condition for pre-PLL divider lower bound Sakari Ailus
2020-09-30 15:28 ` [PATCH 061/100] ccs-pll: Avoid overflow in pre-PLL divisor lower bound search Sakari Ailus
2020-09-30 15:28 ` [PATCH 062/100] ccs-pll: Fix comment on check against maximum PLL multiplier Sakari Ailus
2020-09-30 15:28 ` [PATCH 063/100] ccs-pll: Fix check for PLL multiplier upper bound Sakari Ailus
2020-09-30 15:28 ` [PATCH 064/100] ccs-pll: Use explicit 32-bit unsigned type Sakari Ailus
2020-09-30 15:28 ` [PATCH 065/100] ccs-pll: Add support for lane speed model Sakari Ailus
2020-09-30 15:28 ` [PATCH 066/100] ccs: " Sakari Ailus
2020-09-30 15:28 ` [PATCH 067/100] ccs-pll: Add support for decoupled OP domain calculation Sakari Ailus
2020-09-30 15:28 ` [PATCH 068/100] ccs-pll: Add support for extended input PLL clock divider Sakari Ailus
2020-09-30 15:28 ` [PATCH 069/100] ccs-pll: Support two cycles per pixel on OP domain Sakari Ailus
2020-09-30 15:28 ` [PATCH 070/100] ccs-pll: Add support flexible OP PLL pixel clock divider Sakari Ailus
2020-09-30 15:28 ` [PATCH 071/100] ccs-pll: Add sanity checks Sakari Ailus
2020-09-30 15:28 ` [PATCH 072/100] ccs-pll: Add C-PHY support Sakari Ailus
2020-09-30 15:28 ` Sakari Ailus [this message]
2020-09-30 15:28 ` [PATCH 074/100] ccs-pll: Check for derating and overrating, support non-derating sensors Sakari Ailus
2020-09-30 15:28 ` [PATCH 075/100] ccs-pll: Better separate OP and VT sub-tree calculation Sakari Ailus
2020-09-30 15:28 ` [PATCH 076/100] ccs-pll: Print relevant information on PLL tree Sakari Ailus
2020-09-30 15:28 ` [PATCH 077/100] ccs-pll: Rework bounds checks Sakari Ailus
2020-09-30 15:28 ` [PATCH 078/100] ccs-pll: Make VT divisors 16-bit Sakari Ailus
2020-09-30 15:28 ` [PATCH 079/100] ccs-pll: Fix VT post-PLL divisor calculation Sakari Ailus
2020-09-30 15:28 ` [PATCH 080/100] ccs-pll: Separate VT divisor limit calculation from the rest Sakari Ailus
2020-09-30 15:28 ` [PATCH 081/100] ccs-pll: Add trivial dual PLL support Sakari Ailus
2020-09-30 15:28 ` [PATCH 082/100] ccs: Dual " Sakari Ailus
2020-09-30 15:28 ` [PATCH 083/100] ccs-pll: Add support for DDR OP system and pixel clocks Sakari Ailus
2020-09-30 15:28 ` [PATCH 084/100] ccs: Add support for DDR OP SYS and OP PIX clocks Sakari Ailus
2020-09-30 15:28 ` [PATCH 085/100] ccs: Print written register values Sakari Ailus
2020-09-30 15:28 ` [PATCH 086/100] ccs-pll: Print pixel rates Sakari Ailus
2020-09-30 15:28 ` [PATCH 087/100] ccs: Add support for obtaining C-PHY configuration from firmware Sakari Ailus
2020-09-30 15:28 ` [PATCH 088/100] ccs: Add digital gain support Sakari Ailus
2020-09-30 15:28 ` [PATCH 089/100] ccs: Add support for old-style SMIA digital gain Sakari Ailus
2020-09-30 15:28 ` [PATCH 090/100] ccs: Remove analogue gain field Sakari Ailus
2020-09-30 15:28 ` [PATCH 091/100] ccs: Only add analogue gain control if the device supports it Sakari Ailus
2020-09-30 15:28 ` [PATCH 092/100] v4l: Add user control base for CCS controls Sakari Ailus
2020-09-30 15:28 ` [PATCH 093/100] v4l: uapi: Add controls for analogue gain constants Sakari Ailus
2020-09-30 15:28 ` [PATCH 094/100] ccs: Add support for analogue gain coefficient controls Sakari Ailus
2020-09-30 15:28 ` [PATCH 095/100] v4l: uapi: Add controls for CCS alternative analogue gain Sakari Ailus
2020-09-30 15:28 ` [PATCH 096/100] ccs: Add support for alternate analogue global gain Sakari Ailus
2020-09-30 15:28 ` [PATCH 097/100] ccs: Add debug prints for MSR registers Sakari Ailus
2020-09-30 15:28 ` [PATCH 098/100] v4l: uapi: Add CCS controls for correction configuration and capabilities Sakari Ailus
2020-09-30 15:28 ` [PATCH 099/100] ccs: Add shading correction and luminance correction level controls Sakari Ailus
2020-09-30 15:28 ` [PATCH 100/100] smiapp: Add CCS ACPI device ID Sakari Ailus

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=20200930152858.8471-74-sakari.ailus@linux.intel.com \
    --to=sakari.ailus@linux.intel.com \
    --cc=linux-media@vger.kernel.org \
    /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.