Skip to contentSkip to conversation

clk: imx: composite-8m: Add imx8m_divider_determine_rate

PATCH Applied Adam Ford 6 participants 14 messages May 6, 2023 – Jun 13, 2023

Subsystems (3)
lore
Share & tools
lore

Adam Ford

author
#0 lore raw

PATCH 1/1 clk: imx: composite-8m: Add imx8m_divider_determine_rate

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -0
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
 	return ret;
 }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+				      struct clk_rate_request *req)
+{
+	struct clk_divider *divider = to_clk_divider(hw);
+	int prediv_value;
+	int div_value;
+
+	/* if read only, just return current value */
+	if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+		u32 val;
+
+		val = readl(divider->reg);
+		prediv_value = val >> divider->shift;
+		prediv_value &= clk_div_mask(divider->width);
+		prediv_value++;
+
+		div_value = val >> PCG_DIV_SHIFT;
+		div_value &= clk_div_mask(PCG_DIV_WIDTH);
+		div_value++;
+
+		return divider_ro_determine_rate(hw, req, divider->table,
+						 PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+						 divider->flags, prediv_value * div_value);
+	}
+
+	return divider_determine_rate(hw, req, divider->table,
+				      PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+				      divider->flags);
+}
+
 static const struct clk_ops imx8m_clk_composite_divider_ops = {
 	.recalc_rate = imx8m_clk_composite_divider_recalc_rate,
 	.round_rate = imx8m_clk_composite_divider_round_rate,
 	.set_rate = imx8m_clk_composite_divider_set_rate,
+	.determine_rate = imx8m_divider_determine_rate,
 };
 
 static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
Signature · 1 line
2.39.2
author
#1 lore raw
Quoted 40 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 5 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Peng / Abel,

I was curious if either of you might have time to review this attempt at enabling determine_rate on the 8m's. I tested this on the 8mm, 8mn, and 8mp, and found no regressions.

adam

Quoted 56 lines
Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -1
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
        return ret;
 }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags);
+}
+
 static const struct clk_ops imx8m_clk_composite_divider_ops = {
        .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
        .round_rate = imx8m_clk_composite_divider_round_rate,
        .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
 };
 
 static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

author
#2 lore raw
Quoted 48 lines · Adam Ford
Quoted 40 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 5 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Quoted 5 lines

Peng / Abel,

I was curious if either of you might have time to review this attempt at enabling determine_rate on the 8m's. I tested this on the 8mm, 8mn, and 8mp, and found no regressions.

Gentle nudge.

It's been several weeks since the initial post and the DSI driver is now available for Mini and Nano, so having this in Mini and Nano will really help it sync various video sources.

thanks,

adam

Quoted 58 lines

adam

Quoted 56 lines
Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -1
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
        return ret;
 }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags);
+}
+
 static const struct clk_ops imx8m_clk_composite_divider_ops = {
        .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
        .round_rate = imx8m_clk_composite_divider_round_rate,
        .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
 };
 
 static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

reviewer
#3 lore raw
Quoted 58 lines

Subject: Re: [PATCH] clk: imx: composite-8m: Add
imx8m_divider_determine_rate

Quoted 47 lines · Adam Ford
Quoted 39 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 5 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Quoted 5 lines

Peng / Abel,

I was curious if either of you might have time to review this attempt at enabling determine_rate on the 8m's. I tested this on the 8mm, 8mn, and 8mp, and found no regressions.

Quoted 5 lines

Gentle nudge.

It's been several weeks since the initial post and the DSI driver is now available for Mini and Nano, so having this in Mini and Nano will really help it sync various video sources.

Sorry, overlooked this patch. Will take a look.

Regards,
Peng.

Quoted 65 lines

thanks,

adam

Quoted 10 lines

adam

Quoted 8 lines
Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to

determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

Quoted 6 lines

drivers/clk/imx/clk-composite-8m.c static int

Quoted 6 lines
drivers/clk/imx/clk-composite-8m.c +0 -0
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int

imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,

Quoted 43 lines
Quoted 43 lines
drivers/clk/imx/clk-composite-8m.c +30 -1
        return ret;
 }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags); }
+
 static const struct clk_ops imx8m_clk_composite_divider_ops = {
        .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
        .round_rate = imx8m_clk_composite_divider_round_rate,
        .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
 };
 
 static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

#4 lore raw
In reply to Adam Ford
Quoted 20 lines · Adam Ford

Caution: This is an external email. Please take care when clicking links or opening attachments. When in doubt, report the message using the 'Report this email' button

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

Quoted 5 lines

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Not all clocks has pre/post div both.

If CLK_SET_RATE_PARENT not set, would there be any issues for other clocks?

Regards,
Peng.

Quoted 78 lines

Before:
video_pll 594000000

   video_pll_bypass     594000000
     video_pll_out      594000000
       disp_pixel       31263158
         disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:
video_pll 31500000

   video_pll_bypass      31500000
     video_pll_out       31500000
       disp_pixel        31500000
         disp_pixel_clk  31500000

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -1
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
         return ret;
  }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags);
+}
+
  static const struct clk_ops imx8m_clk_composite_divider_ops = {
         .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
         .round_rate = imx8m_clk_composite_divider_round_rate,
         .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
  };
 
  static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

author
#5 lore raw
Quoted 30 lines · Peng Fan
Quoted 20 lines · Adam Ford

Caution: This is an external email. Please take care when clicking links or opening attachments. When in doubt, report the message using the 'Report this email' button

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

Quoted 5 lines

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Quoted 4 lines

Not all clocks has pre/post div both.

If CLK_SET_RATE_PARENT not set, would there be any issues for other clocks?

I did a dump of the clk_summary for Mini, Nano and Plus, and I found no changes to any clock other than the video_pll, and most of the clocks do not have CLK_SET_RATE_PARENT set, so from what I could tell it seemed harmless.

Quoted 82 lines

Regards,
Peng.

Quoted 78 lines

Before:
video_pll 594000000

   video_pll_bypass     594000000
     video_pll_out      594000000
       disp_pixel       31263158
         disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:
video_pll 31500000

   video_pll_bypass      31500000
     video_pll_out       31500000
       disp_pixel        31500000
         disp_pixel_clk  31500000

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -1
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
         return ret;
  }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags);
+}
+
  static const struct clk_ops imx8m_clk_composite_divider_ops = {
         .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
         .round_rate = imx8m_clk_composite_divider_round_rate,
         .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
  };
 
  static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

author
#6 lore raw
Quoted 26 lines · Adam Ford
Quoted 24 lines · Peng Fan
Quoted 20 lines · Adam Ford

Caution: This is an external email. Please take care when clicking links or opening attachments. When in doubt, report the message using the 'Report this email' button

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

Quoted 7 lines
Quoted 7 lines
Quoted 5 lines

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Not all clocks has pre/post div both.

Peng,

Any suggestions on how to identify this? looking at the code that sets the clock rates, it seemed to me like the code was mostly common code and it looked like the pre and post div's were basically the same. CAn you point me to an example where they're identified with different values?

Quoted 8 lines
Quoted 3 lines

If CLK_SET_RATE_PARENT not set, would there be any issues for other clocks?

I did a dump of the clk_summary for Mini, Nano and Plus, and I found no changes to any clock other than the video_pll, and most of the clocks do not have CLK_SET_RATE_PARENT set, so from what I could tell it seemed harmless.

What do you need from me to be able to move this forward?

thanks

adam

Quoted 83 lines
Quoted 83 lines

Regards,
Peng.

Quoted 78 lines

Before:
video_pll 594000000

   video_pll_bypass     594000000
     video_pll_out      594000000
       disp_pixel       31263158
         disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:
video_pll 31500000

   video_pll_bypass      31500000
     video_pll_out       31500000
       disp_pixel        31500000
         disp_pixel_clk  31500000

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -1
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
         return ret;
  }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+                                     struct clk_rate_request *req)
+{
+       struct clk_divider *divider = to_clk_divider(hw);
+       int prediv_value;
+       int div_value;
+
+       /* if read only, just return current value */
+       if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+               u32 val;
+
+               val = readl(divider->reg);
+               prediv_value = val >> divider->shift;
+               prediv_value &= clk_div_mask(divider->width);
+               prediv_value++;
+
+               div_value = val >> PCG_DIV_SHIFT;
+               div_value &= clk_div_mask(PCG_DIV_WIDTH);
+               div_value++;
+
+               return divider_ro_determine_rate(hw, req, divider->table,
+                                                PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                                divider->flags, prediv_value * div_value);
+       }
+
+       return divider_determine_rate(hw, req, divider->table,
+                                     PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+                                     divider->flags);
+}
+
  static const struct clk_ops imx8m_clk_composite_divider_ops = {
         .recalc_rate = imx8m_clk_composite_divider_recalc_rate,
         .round_rate = imx8m_clk_composite_divider_round_rate,
         .set_rate = imx8m_clk_composite_divider_set_rate,
+       .determine_rate = imx8m_divider_determine_rate,
  };
 
  static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
--

2.39.2

reviewer Tested-by on v1 1/1
#7 lore raw
In reply to Adam Ford
Quoted 40 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

This works fine on my imx8mm-evk, so:

author
#8 lore raw
Quoted 8 lines · Fabio Estevam
Quoted 6 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

+ Maxime

Quoted 34 lines
Quoted 34 lines

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 8 lines
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

Peng / Abel,

Any suggestions on how we can move this forward? Looking at the clk-composite-8m driver, imx8m_clk_composite_compute_dividers uses the max values which is basically what my patch does. There was some discussion about making determine_rate mandatory for muxes[1] and this patch should help with this in addition to making it easier to sync more video resolutions on the 8m Mini and Nano.

adam
[1] - https://www.spinics.net/lists/alsa-devel/msg157914.html

Quoted 3 lines

This works fine on my imx8mm-evk, so:

#9 lore raw
Quoted 55 lines · Adam Ford
Quoted 8 lines · Fabio Estevam
Quoted 6 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

+ Maxime

Quoted 34 lines
Quoted 34 lines

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 8 lines
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")
Quoted 8 lines

Peng / Abel,

Any suggestions on how we can move this forward? Looking at the clk-composite-8m driver, imx8m_clk_composite_compute_dividers uses the max values which is basically what my patch does. There was some discussion about making determine_rate mandatory for muxes[1] and this patch should help with this in addition to making it easier to sync more video resolutions on the 8m Mini and Nano.

Those patches have been queued by Stephen for 6.6 :)

Maxime

author
#10 lore raw
Quoted 59 lines · Maxime Ripard
Quoted 57 lines · Adam Ford
Quoted 8 lines · Fabio Estevam
Quoted 6 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

+ Maxime

Quoted 34 lines
Quoted 34 lines

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 8 lines
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

Peng / Abel,

Quoted 8 lines
Quoted 6 lines

Any suggestions on how we can move this forward? Looking at the clk-composite-8m driver, imx8m_clk_composite_compute_dividers uses the max values which is basically what my patch does. There was some discussion about making determine_rate mandatory for muxes[1] and this patch should help with this in addition to making it easier to sync more video resolutions on the 8m Mini and Nano.

Those patches have been queued by Stephen for 6.6 :)

One of the patches in the older series was reverted, but this was to address the patch that was reverted.

adam

Quoted 2 lines

Maxime

#11 lore raw
Quoted 67 lines · Adam Ford
Quoted 66 lines · Maxime Ripard
Quoted 63 lines · Adam Ford
Quoted 8 lines · Fabio Estevam
Quoted 6 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

+ Maxime

Quoted 34 lines
Quoted 34 lines

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 8 lines
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")

Peng / Abel,

Any suggestions on how we can move this forward? Looking at the clk-composite-8m driver, imx8m_clk_composite_compute_dividers uses the max values which is basically what my patch does. There was some discussion about making determine_rate mandatory for muxes[1] and this patch should help with this in addition to making it easier to sync more video resolutions on the 8m Mini and Nano.

Quoted 4 lines
Quoted 1 line

Those patches have been queued by Stephen for 6.6 :)

One of the patches in the older series was reverted, but this was to address the patch that was reverted.

Was it? I haven't been cc'd and it doesn't seem to be in -next either?

Maxime

Reviewed-by on v1 1/1
#12 lore raw
In reply to Adam Ford
Quoted 39 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

With this added, the system can attempt to adjust the parent rate when the proper flags are set which can lead to a more precise clock value.

On the imx8mplus, no clock changes are present.
On the Mini and Nano, this can help achieve more accurate lcdif clocks. When trying to get a pixel clock of 31.500MHz on an imx8m Nano, the clocks divided the 594MHz down, but left the parent rate untouched which caused a calulation error.

Before:

video_pll              594000000
  video_pll_bypass     594000000
    video_pll_out      594000000
      disp_pixel       31263158
        disp_pixel_clk 31263158

Variance = -236842 Hz

After this patch:

video_pll               31500000
  video_pll_bypass      31500000
    video_pll_out       31500000
      disp_pixel        31500000
        disp_pixel_clk  31500000
Quoted 7 lines

Variance = 0 Hz

All other clocks rates and parent were the same.
Similar results on imx8mm were found.

Fixes 690dccc4a0bf ("Revert "clk: imx: composite-8m: Add support to determine_rate"")
Quoted 54 lines

---
V2: Fix build warning found by build bot and fix prediv_value
and div_value because the values stored are the divisor - 1, so we need to add 1 to the values to be correct.

drivers/clk/imx/clk-composite-8m.c +31 -0
index cbf0d7955a00..7a6e3ce97133 100644
@@ -119,10 +119,41 @@ static int imx8m_clk_composite_divider_set_rate(struct clk_hw *hw,
 	return ret;
 }
 
+static int imx8m_divider_determine_rate(struct clk_hw *hw,
+				      struct clk_rate_request *req)
+{
+	struct clk_divider *divider = to_clk_divider(hw);
+	int prediv_value;
+	int div_value;
+
+	/* if read only, just return current value */
+	if (divider->flags & CLK_DIVIDER_READ_ONLY) {
+		u32 val;
+
+		val = readl(divider->reg);
+		prediv_value = val >> divider->shift;
+		prediv_value &= clk_div_mask(divider->width);
+		prediv_value++;
+
+		div_value = val >> PCG_DIV_SHIFT;
+		div_value &= clk_div_mask(PCG_DIV_WIDTH);
+		div_value++;
+
+		return divider_ro_determine_rate(hw, req, divider->table,
+						 PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+						 divider->flags, prediv_value * div_value);
+	}
+
+	return divider_determine_rate(hw, req, divider->table,
+				      PCG_PREDIV_WIDTH + PCG_DIV_WIDTH,
+				      divider->flags);
+}
+
 static const struct clk_ops imx8m_clk_composite_divider_ops = {
 	.recalc_rate = imx8m_clk_composite_divider_recalc_rate,
 	.round_rate = imx8m_clk_composite_divider_round_rate,
 	.set_rate = imx8m_clk_composite_divider_set_rate,
+	.determine_rate = imx8m_divider_determine_rate,
 };
 
 static u8 imx8m_clk_composite_mux_get_parent(struct clk_hw *hw)
Signature · 1 line
2.39.2
Applied
#13 lore raw
In reply to Adam Ford
Quoted 13 lines · Adam Ford

Currently, certain clocks are derrived as a divider from their parent clock. For some clocks, even when CLK_SET_RATE_PARENT is set, the parent clock is not properly set which can lead to some relatively inaccurate clock values.

Unlike imx/clk-composite-93 and imx/clk-divider-gate, it cannot rely on calling a standard determine_rate function, because the 8m composite clocks have a pre-divider and post-divider. Because of this, a custom determine_rate function is necessary to determine the maximum clock division which is equivalent to pre-divider * the post-divider.

Quoted 1 line

[...]

Applied, thanks!

[1/1] clk: imx: composite-8m: Add imx8m_divider_determine_rate

      commit: 8208181fe536bba3b411508f81c4426fc9c71d9a

Best regards,

Signature · 1 line
Abel Vesa <[email protected]>