Skip to contentSkip to conversation

ccf: where to put constraints?

DISCUSSION Wolfram Sang 3 participants 8 messages Feb 24, 2014 – Mar 1, 2014

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

Thanks,

Wolfram

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140224/905abefb/attachment.sig>

#1 lore raw

Hi Wolfram,

Quoted 8 lines · Wolfram Sang

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

I don't know if it's the best or only way, but so far, I did things like that with clock notifiers.

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier. In that notifier callback it then can react to the rate change. E.g. adjust dividers to stay within legal limits or reject the change completely.

S?ren

#2 lore raw

Quoting S?ren Brinkmann (2014-02-24 13:21:58)

Quoted 12 lines

Hi Wolfram,

Quoted 8 lines · Wolfram Sang

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

Quoted 7 lines

I don't know if it's the best or only way, but so far, I did things like that with clock notifiers.

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier. In that notifier callback it then can react to the rate change. E.g. adjust dividers to stay within legal limits or reject the change completely.

Yes, this is why the notifiers were created. A nice side effect of this is that the code can live outside your clock driver. Often times the clocks are quite capable of running at these speeds, but the problem is the IP blocks (CPU & GPU in Wolfram's case) would be out of spec. It is arguable that this logic does not belong in the clock driver but instead in some cpufreq driver or something like it.

The clock notifiers make it easy to put this logic wherever you like and you can even veto clock rate changes.

Regards,
Mike

Quoted 4 lines

S?ren

#3 lore raw
Quoted 28 lines · Mike Turquette

Quoting S?ren Brinkmann (2014-02-24 13:21:58)

Quoted 12 lines

Hi Wolfram,

Quoted 8 lines · Wolfram Sang

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

Quoted 7 lines

I don't know if it's the best or only way, but so far, I did things like that with clock notifiers.

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier. In that notifier callback it then can react to the rate change. E.g. adjust dividers to stay within legal limits or reject the change completely.

Yes, this is why the notifiers were created. A nice side effect of this is that the code can live outside your clock driver. Often times the clocks are quite capable of running at these speeds, but the problem is the IP blocks (CPU & GPU in Wolfram's case) would be out of spec. It is arguable that this logic does not belong in the clock driver but instead in some cpufreq driver or something like it.

Quoted 2 lines

The clock notifiers make it easy to put this logic wherever you like and you can even veto clock rate changes.

Right, that's how I have it. If a device driver needs to enforce some policy on its clock, it implements a clock notifier callback.

The drawback though, as I see it, it makes interactions hard to understand. With such a scheme, rate changes may fail and the cause is not always obvious - often hidden really well. Usually all you get is a message from the CCF that the rate change for clock <name> failed, but if your notifier callback isn't verbose, you can search forever for the cause of that failure.

On our internal repo I had it a few times that "bugs" get assigned to the wrong piece. E.g. cpufreq, even though that works perfectly well and correct on its own, but some other device enforced some policy through a notifier.

S?ren

#4 lore raw

Quoting S?ren Brinkmann (2014-02-24 15:11:55)

Quoted 42 lines · Mike Turquette
Quoted 28 lines

Quoting S?ren Brinkmann (2014-02-24 13:21:58)

Quoted 12 lines

Hi Wolfram,

Quoted 8 lines · Wolfram Sang

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

Quoted 7 lines

I don't know if it's the best or only way, but so far, I did things like that with clock notifiers.

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier. In that notifier callback it then can react to the rate change. E.g. adjust dividers to stay within legal limits or reject the change completely.

Yes, this is why the notifiers were created. A nice side effect of this is that the code can live outside your clock driver. Often times the clocks are quite capable of running at these speeds, but the problem is the IP blocks (CPU & GPU in Wolfram's case) would be out of spec. It is arguable that this logic does not belong in the clock driver but instead in some cpufreq driver or something like it.

Quoted 2 lines

The clock notifiers make it easy to put this logic wherever you like and you can even veto clock rate changes.

Right, that's how I have it. If a device driver needs to enforce some policy on its clock, it implements a clock notifier callback.

The drawback though, as I see it, it makes interactions hard to understand. With such a scheme, rate changes may fail and the cause is not always obvious - often hidden really well. Usually all you get is a message from the CCF that the rate change for clock <name> failed, but if your notifier callback isn't verbose, you can search forever for the cause of that failure.

Quoted 4 lines

On our internal repo I had it a few times that "bugs" get assigned to the wrong piece. E.g. cpufreq, even though that works perfectly well and correct on its own, but some other device enforced some policy through a notifier.

Yes, debugging across notifiers is notoriously annoying. How about something like the following patch?

Regards,
Mike

Quoted 1 line

From f5b30cad56b3439ac127b43148827a95f6391a92 Mon Sep 17 00:00:00 2001

From: Mike Turquette <[email protected]>
Date: Mon, 24 Feb 2014 16:08:41 -0800
Subject: [PATCH] clk: add pr_err and kerneldoc around clk notifiers
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Both the pr_err and the additional kerneldoc aim to help when debugging errors thrown from within a clock rate-change notifier callback.

---
 drivers/clk/clk.c   |  5 ++++-
 include/linux/clk.h | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)
drivers/clk/clk.c +4 -1
index a6f079d..1a95b92 100644
@@ -1339,8 +1339,11 @@ static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
 	if (clk->notifier_count)
 		ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
 
-	if (ret & NOTIFY_STOP_MASK)
+	if (ret & NOTIFY_STOP_MASK) {
+		pr_err("%s: clk notifier callback for clock %s aborted with error %d\n",
+				__func__, clk->name, ret);
 		goto out;
+	}
 
 	hlist_for_each_entry(child, &clk->children, child_node) {
 		ret = __clk_speculate_rates(child, new_rate);
include/linux/clk.h +14 -0
index 0dd9114..35a7e00 100644
@@ -78,8 +78,22 @@ struct clk_notifier_data {
 	unsigned long		new_rate;
 };
 
+/**
+ * clk_notifier_register: register a clock rate-change notifier callback
+ * @clk: clock whose rate we are interested in
+ * @nb: notifier block with callback function pointer
+ *
+ * ProTip: debugging across notifier chains can be frustrating. Make sure that
+ * your notifier callback function prints a nice big warning in case of
+ * failure.
+ */
 int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
 
+/**
+ * clk_notifier_unregister: unregister a clock rate-change notifier callback
+ * @clk: clock whose rate we are no longer interested in
+ * @nb: notifier block which will be unregistered
+ */
 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
 
 /**
Signature · 1 line
1.8.3.2
#5 lore raw
Quoted 43 lines · Mike Turquette

Quoting S?ren Brinkmann (2014-02-24 15:11:55)

Quoted 42 lines · Mike Turquette
Quoted 28 lines

Quoting S?ren Brinkmann (2014-02-24 13:21:58)

Quoted 12 lines

Hi Wolfram,

Quoted 8 lines · Wolfram Sang

Hi,

Where do I put constraints when using the CCF? I have a CPU and GPU clock derived from the same PLL. Both clocks have their own divider. Now, there is the additional constraint that the CPU clock must not be lower than the GPU clock. Do I add checks in the set_rate functions? Feels like the wrong layer, but not checking it and blindly relying on somebody else does not feel correct, too. How to do it best?

Quoted 7 lines

I don't know if it's the best or only way, but so far, I did things like that with clock notifiers.

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier. In that notifier callback it then can react to the rate change. E.g. adjust dividers to stay within legal limits or reject the change completely.

Yes, this is why the notifiers were created. A nice side effect of this is that the code can live outside your clock driver. Often times the clocks are quite capable of running at these speeds, but the problem is the IP blocks (CPU & GPU in Wolfram's case) would be out of spec. It is arguable that this logic does not belong in the clock driver but instead in some cpufreq driver or something like it.

Quoted 2 lines

The clock notifiers make it easy to put this logic wherever you like and you can even veto clock rate changes.

Right, that's how I have it. If a device driver needs to enforce some policy on its clock, it implements a clock notifier callback.

The drawback though, as I see it, it makes interactions hard to understand. With such a scheme, rate changes may fail and the cause is not always obvious - often hidden really well. Usually all you get is a message from the CCF that the rate change for clock <name> failed, but if your notifier callback isn't verbose, you can search forever for the cause of that failure.

Quoted 7 lines
Quoted 4 lines

On our internal repo I had it a few times that "bugs" get assigned to the wrong piece. E.g. cpufreq, even though that works perfectly well and correct on its own, but some other device enforced some policy through a notifier.

Yes, debugging across notifiers is notoriously annoying. How about something like the following patch?

Good idea. Now I should just follow that advice and my life may become a lot easier :)
ACK

Thanks,
S?ren

#6 lore raw
In reply to Sören Brinkmann

Hi S?ren,

Quoted 2 lines

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier.

I found the notifiers, too, but I am still not sure they are proper for my case. There, CPU and GPU clocks are siblings, there is no parent-child relationship.

Anyhow, I have been told cpufreq is not needed currently, so this task is postponed. Thanks for the input nonetheless!

Wolfram

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 836 bytes
Desc: Digital signature
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20140228/6738af04/attachment.sig>

#7 lore raw
Quoted 8 lines · Wolfram Sang

Hi S?ren,

Quoted 2 lines

I.e. when a clock consumer needs to be notified about its input clock being changed it registers a clock notifier.

I found the notifiers, too, but I am still not sure they are proper for my case. There, CPU and GPU clocks are siblings, there is no parent-child relationship.

Hi Wolfram,

No parent-child relationship is required. The cpufreq driver you have in mind could subscribe to notifiers for both your GPU clock as well as your CPU clock and listen for any changes, waiting to take action.

Regards,
Mike

Quoted 6 lines

Anyhow, I have been told cpufreq is not needed currently, so this task is postponed. Thanks for the input nonetheless!

Wolfram