regulator: Prevent falling too fast
Subsystems (2)
PATCH v4 4/4 regulator: Prevent falling too fast
From: Douglas Anderson <[email protected]>
On some boards it's possible that transitioning the PWM regulator downwards too fast will trigger the over voltage protection (OVP) on the regulator. This is because until the voltage actually falls there is a time when the requested voltage is much lower than the actual voltage.
We'll fix this OVP problem by allowing users to specify the maximum voltage that we can safely fall. Apparently this maximum safe voltage should be specified as a percentage of the current voltage. The regulator will then break things into separate steps with a delay in between.
In order to figure out what the delay should be we need to figure out how slowly the voltage rail might fall in the worst (slowest) case. We'll assume this worst case is present and delay so we know for sure that we've finished each step.
In this patch we actually block returning from the set_voltage() call until we've finished delaying. A future patch atop this one might choose to return more immediately and let the voltages fall in the background. That would possibly to allow us to cancel a slow downward decay if there was a request to go back up.
---
Changes in v4:
- Moved from PWM regulator to regulator core
- Added 'regulator' prefix to device tree properties
.../devicetree/bindings/regulator/regulator.txt | 7 +++ drivers/regulator/core.c | 58 ++++++++++++++++++---- drivers/regulator/of_regulator.c | 34 +++++++++++++ include/linux/regulator/machine.h | 2 + 4 files changed, 92 insertions(+), 9 deletions(-)
Documentation/devicetree/bindings/regulator/regulator.txt +7 -0
@@ -23,6 +23,13 @@ Optional properties: and board design issues such as trace capacitance and load on the supply. - regulator-settle-time-up-us: Time to settle down after a voltage increase (unit: us). For regulators with a ramp delay the two values are added. +- regulator-safe-fall-percent: If specified, it's not safe to transition the + regulator down faster than this amount and bigger jumps need to be broken into + more than one step. +- regulator-slowest-decay-rate: Describes how slowly the regulator voltage will + decay down in the worst case (lightest expected load). Specified in uV / us + (like main regulator ramp rate). This is required when safe-fall-percent is + specified. - regulator-soft-start: Enable soft start so that voltage ramps slowly - regulator-state-mem sub-root node for Suspend-to-RAM mode : suspend to memory, the device goes to sleep, but all data stored in memory,
drivers/regulator/core.c +49 -9
97 lines not on this page · raw message
drivers/regulator/of_regulator.c +34 -0
@@ -94,6 +94,40 @@ static void of_get_regulation_constraints(struct device_node *np,if (!ret) constraints->settle_time_up = pval; + ret =of_property_read_u32 (np,"regulator-slowest-decay-rate" , &pval); +if (!ret) + constraints->slowest_decay_rate = pval; +else + constraints->slowest_decay_rate =INT_MAX ; + + ret =of_property_read_u32 (np,"regulator-safe-fall-percent" , &pval); +if (!ret) + constraints->safe_fall_percent = pval; + +/* We use the value as int and as divider; sanity check */ +if (constraints->slowest_decay_rate ==0 ) { +pr_err ("%s: regulator-slowest-decay-rate must not be 0\n" , + np->name); + constraints->slowest_decay_rate =INT_MAX ; + }else if (constraints->slowest_decay_rate >INT_MAX ) { +pr_err ("%s: regulator-slowest-decay-rate (%u) too big\n" , + np->name, constraints->slowest_decay_rate); + constraints->slowest_decay_rate =INT_MAX ; + } + +if (constraints->safe_fall_percent >100 ) { +pr_err ("%s: regulator-safe-fall-percent (%u) > 100\n" , + np->name, constraints->safe_fall_percent); + constraints->safe_fall_percent =0 ; + } + +if (constraints->safe_fall_percent && + !constraints->slowest_decay_rate) { +pr_err ("%s: regulator-slowest-decay-rate requires " +"regulator-safe-fall-percent\n" , np->name); + constraints->safe_fall_percent =0 ; + } + constraints->soft_start =of_property_read_bool (np,"regulator-soft-start" ); ret =of_property_read_u32 (np,"regulator-active-discharge" , &pval);
include/linux/regulator/machine.h +2 -0
@@ -152,6 +152,8 @@ struct regulation_constraints {unsigned int ramp_delay;unsigned int enable_time;unsigned int settle_time_up; +unsigned int slowest_decay_rate; +unsigned int safe_fall_percent;unsigned int active_discharge;
Signature · 7 lines
2.8.0.rc3.226.g39d4020 -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 4 lines · Matthias Kaehlcke
On some boards it's possible that transitioning the PWM regulator downwards too fast will trigger the over voltage protection (OVP) on the regulator. This is because until the voltage actually falls there is a time when the requested voltage is much lower than the actual voltage.
So your PWM regulators are not very good and overshooting? Do you have any numbers on this - what values do you end up setting for both the delay and safe fall percentages?
Quoted 5 lines
We'll fix this OVP problem by allowing users to specify the maximum voltage that we can safely fall. Apparently this maximum safe voltage should be specified as a percentage of the current voltage. The regulator will then break things into separate steps with a delay in between.
I'd like to see some more thorough analysis than just an "apparently" here. It's making the code more fiddly for something very handwavy.
Quoted 10 lines
drivers/regulator/core.c +0
-2@@ -2753,8 +2753,6 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,int old_selector =-1 ;int old_uV =_regulator_get_voltage (rdev); -trace_regulator_set_voltage (rdev_get_name (rdev), min_uV, max_uV); - min_uV += rdev->constraints->uV_offset; max_uV += rdev->constraints->uV_offset;
drivers/regulator/core.c no_delay: · line 2843
Quoted 6 lines
drivers/regulator/core.c +0
-2@@ -2842,11 +2840,53 @@ no_delay: (void *)data); } -trace_regulator_set_voltage_complete (rdev_get_name (rdev), best_val); -return ret;
Let's remove some trace points too because...? These *are* the actual voltage changes in the device, we're just splitting things up into a series of transitions.
drivers/regulator/core.c no_delay: · line 2858
Quoted 13 lines
drivers/regulator/core.c +13
-0+static int _regulator_set_voltage (struct regulator_dev *rdev, +int min_uV,int max_uV) +{ +int safe_fall_percent = rdev->constraints->safe_fall_percent; +int slowest_decay_rate = rdev->constraints->slowest_decay_rate; +int orig_uV =_regulator_get_voltage (rdev); +int uV = orig_uV; +int ret; + +trace_regulator_set_voltage (rdev_get_name (rdev), min_uV, max_uV); + +/* If we're rising or we're falling but don't need to slow; easy */ +if (min_uV >= uV || !safe_fall_percent)
Indentation is broken, the two lines above don't agree with each other.
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 101
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+ ret =of_property_read_u32 (np,"regulator-slowest-decay-rate" , &pval); +if (!ret) + constraints->slowest_decay_rate = pval; +else + constraints->slowest_decay_rate =INT_MAX ;
The documentation said this is mandatory if we have a safe fall rate specified but the code says it's optional and we'll silently default to an absurdly high rate instead (it's odd that a large number in a field marked slowest is fast BTW). Complaining loudly seems better than ignoring the error.
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 116
Quoted 10 lines
drivers/regulator/of_regulator.c +10
-0+/* We use the value as int and as divider; sanity check */ +if (constraints->slowest_decay_rate ==0 ) { +pr_err ("%s: regulator-slowest-decay-rate must not be 0\n" , + np->name); + constraints->slowest_decay_rate =INT_MAX ; + }else if (constraints->slowest_decay_rate >INT_MAX ) { +pr_err ("%s: regulator-slowest-decay-rate (%u) too big\n" , + np->name, constraints->slowest_decay_rate); + constraints->slowest_decay_rate =INT_MAX ; + }
This should be with the parsing of slowest-decay-rate and checked only if we have a safe-fall-percent, there's no error if the value is omitted.
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 122
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+if (constraints->safe_fall_percent >100 ) { +pr_err ("%s: regulator-safe-fall-percent (%u) > 100\n" , + np->name, constraints->safe_fall_percent); + constraints->safe_fall_percent =0 ; + }
Again indentation is borked here, I think you have tab/space issues.
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 127
Quoted 4 lines
drivers/regulator/of_regulator.c +4
-0+if (constraints->safe_fall_percent && + !constraints->slowest_decay_rate) { +pr_err ("%s: regulator-slowest-decay-rate requires " +"regulator-safe-fall-percent\n" , np->name);
Don't align the second line of the condition with the body of the if, that just makes things hard to read - do what the rest of the code does and align with the (.
Don't split text messages over multiple lines, it makes it impossible to grep for the error as printed.
Hi Mark,
thanks for your review, please find my comments (including info from our EE) below.
El Mon, Sep 12, 2016 at 07:56:33PM +0100 Mark Brown ha dit:
Quoted 10 lines · Matthias Kaehlcke
Quoted 5 lines
On some boards it's possible that transitioning the PWM regulator downwards too fast will trigger the over voltage protection (OVP) on the regulator. This is because until the voltage actually falls there is a time when the requested voltage is much lower than the actual voltage.
So your PWM regulators are not very good and overshooting? Do you have any numbers on this - what values do you end up setting for both the delay and safe fall percentages?
No, they just don't actively discharge the rail. Instead, they depend on the rail self-discharging via the load (the SoC). If the load is small, it takes longer to transition.
Optimizing the delay time depends on the SoC; we have not measured this across a wide variety of devices and thus have very conservative numbers. The percentage is based on the trigger for OVP on the regulator. In this case, OVP kicks in when the FB node is 20% over regulation, which is equivalent to a 16% drop in voltage (1/1.2). For our device safe-fall-percent is set to 16 and slowest-decay-rate is 225.
Quoted 8 lines
Quoted 5 lines
We'll fix this OVP problem by allowing users to specify the maximum voltage that we can safely fall. Apparently this maximum safe voltage should be specified as a percentage of the current voltage. The regulator will then break things into separate steps with a delay in between.
I'd like to see some more thorough analysis than just an "apparently" here. It's making the code more fiddly for something very handwavy.
It's well-understood why it's a percentage. DVS is controlled by offsetting the FB current, and as above, OVP is based on how far you are from the FB target.
Quoted 13 lines
Quoted 13 lines
drivers/regulator/core.c +0
-2@@ -2753,8 +2753,6 @@ static int _regulator_do_set_voltage(struct regulator_dev *rdev,int old_selector =-1 ;int old_uV =_regulator_get_voltage (rdev); -trace_regulator_set_voltage (rdev_get_name (rdev), min_uV, max_uV); - min_uV += rdev->constraints->uV_offset; max_uV += rdev->constraints->uV_offset;@@ -2842,11 +2840,53 @@ no_delay: (void *)data); }
Quoted 7 lines
drivers/regulator/core.c no_delay: · line 2843
Quoted 3 lines
drivers/regulator/core.c +0
-2-trace_regulator_set_voltage_complete (rdev_get_name (rdev), best_val); -return ret;Let's remove some trace points too because...? These *are* the actual voltage changes in the device, we're just splitting things up into a series of transitions.
I wasn't sure whether to keep reporting a single voltage change or the individual steps. Will leave the trace points at their original location.
Quoted 7 lines
Quoted 7 lines
drivers/regulator/core.c +7
-0+static int _regulator_set_voltage (struct regulator_dev *rdev, +int min_uV,int max_uV) +{ +int safe_fall_percent = rdev->constraints->safe_fall_percent; +int slowest_decay_rate = rdev->constraints->slowest_decay_rate; +int orig_uV =_regulator_get_voltage (rdev); +int uV = orig_uV;
Quoted 8 lines
drivers/regulator/core.c no_delay: · line 2858
Quoted 6 lines
drivers/regulator/core.c +6
-0+int ret; + +trace_regulator_set_voltage (rdev_get_name (rdev), min_uV, max_uV); + +/* If we're rising or we're falling but don't need to slow; easy */ +if (min_uV >= uV || !safe_fall_percent)Indentation is broken, the two lines above don't agree with each other.
Will fix
Quoted 11 lines
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 101
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+ ret =of_property_read_u32 (np,"regulator-slowest-decay-rate" , &pval); +if (!ret) + constraints->slowest_decay_rate = pval; +else + constraints->slowest_decay_rate =INT_MAX ;The documentation said this is mandatory if we have a safe fall rate specified but the code says it's optional and we'll silently default to an absurdly high rate instead (it's odd that a large number in a field marked slowest is fast BTW). Complaining loudly seems better than ignoring the error.
Agreed about complaining. Since there isn't really a reasonable default value it's probably best to change the interface of the function and return an error in this case.
Quoted 5 lines
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+/* We use the value as int and as divider; sanity check */ +if (constraints->slowest_decay_rate ==0 ) { +pr_err ("%s: regulator-slowest-decay-rate must not be 0\n" , + np->name); + constraints->slowest_decay_rate =INT_MAX ;
Quoted 8 lines
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 116
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+ }else if (constraints->slowest_decay_rate >INT_MAX ) { +pr_err ("%s: regulator-slowest-decay-rate (%u) too big\n" , + np->name, constraints->slowest_decay_rate); + constraints->slowest_decay_rate =INT_MAX ; + }This should be with the parsing of slowest-decay-rate and checked only if we have a safe-fall-percent, there's no error if the value is omitted.
Will change
Quoted 7 lines
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 122
Quoted 5 lines
drivers/regulator/of_regulator.c +5
-0+if (constraints->safe_fall_percent >100 ) { +pr_err ("%s: regulator-safe-fall-percent (%u) > 100\n" , + np->name, constraints->safe_fall_percent); + constraints->safe_fall_percent =0 ; + }Again indentation is borked here, I think you have tab/space issues.
Ok, I will keep an eye on it
Quoted 11 lines
drivers/regulator/of_regulator.c static void of_get_regulation_constraints(struct device_node *np, · line 127
Quoted 4 lines
drivers/regulator/of_regulator.c +4
-0+if (constraints->safe_fall_percent && + !constraints->slowest_decay_rate) { +pr_err ("%s: regulator-slowest-decay-rate requires " +"regulator-safe-fall-percent\n" , np->name);Don't align the second line of the condition with the body of the if, that just makes things hard to read - do what the rest of the code does and align with the (.
Don't split text messages over multiple lines, it makes it impossible to grep for the error as printed.
ok
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 7 lines · Matthias Kaehlcke
Optimizing the delay time depends on the SoC; we have not measured this across a wide variety of devices and thus have very conservative numbers. The percentage is based on the trigger for OVP on the regulator. In this case, OVP kicks in when the FB node is 20% over regulation, which is equivalent to a 16% drop in voltage (1/1.2). For our device safe-fall-percent is set to 16 and slowest-decay-rate is 225.
The obvious question here is how the OVP hardware knows about the new voltage and why we're bodging this in the regulator core rather than in the OVP hardware.
Quoted 6 lines
Quoted 2 lines
I'd like to see some more thorough analysis than just an "apparently" here. It's making the code more fiddly for something very handwavy.
It's well-understood why it's a percentage. DVS is controlled by offsetting the FB current, and as above, OVP is based on how far you are from the FB target.
You might think you understand this clearly but nobody reading the commit message or looking at the code later on is going to be able do so when your commit message only contains vague handwaving.
Hi Mark,
El Thu, Sep 15, 2016 at 03:39:45PM +0100 Mark Brown ha dit:
Quoted 10 lines · Matthias Kaehlcke
Quoted 8 lines
Optimizing the delay time depends on the SoC; we have not measured this across a wide variety of devices and thus have very conservative numbers. The percentage is based on the trigger for OVP on the regulator. In this case, OVP kicks in when the FB node is 20% over regulation, which is equivalent to a 16% drop in voltage (1/1.2). For our device safe-fall-percent is set to 16 and slowest-decay-rate is 225.
Quoted 3 lines
The obvious question here is how the OVP hardware knows about the new voltage and why we're bodging this in the regulator core rather than in the OVP hardware.
The OVP hardware is part of the regulator and the regulator is not notified directly about voltage changes. The regulator transforms the PWM input into DC output and does the OVP internally with the limits described above.
Quoted 10 lines
Quoted 6 lines
Quoted 2 lines
I'd like to see some more thorough analysis than just an "apparently" here. It's making the code more fiddly for something very handwavy.
It's well-understood why it's a percentage. DVS is controlled by offsetting the FB current, and as above, OVP is based on how far you are from the FB target.
You might think you understand this clearly but nobody reading the commit message or looking at the code later on is going to be able do so when your commit message only contains vague handwaving.
In case there is a next revision of this patch (i.e. if it is deemed useful beyond our specific use case) I can include the details in the commit message of the next revision. Sorry for omitting them initially, to me it seemed to be very device specific information, but I understand that these details can be helpful to understand the context.
Matthias
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 10 lines · Matthias Kaehlcke
El Thu, Sep 15, 2016 at 03:39:45PM +0100 Mark Brown ha dit:
Quoted 3 lines
The obvious question here is how the OVP hardware knows about the new voltage and why we're bodging this in the regulator core rather than in the OVP hardware.
The OVP hardware is part of the regulator and the regulator is not notified directly about voltage changes. The regulator transforms the PWM input into DC output and does the OVP internally with the limits described above.
So the PWM is just configuring this external regulator chip (which doesn't seem to be described in DT...) and that's just incredibly bad at coping with voltage changes? It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
El Fri, Sep 16, 2016 at 05:32:53PM +0100 Mark Brown ha dit:
Quoted 7 lines · Matthias Kaehlcke
Quoted 5 lines
El Thu, Sep 15, 2016 at 03:39:45PM +0100 Mark Brown ha dit:
Quoted 3 lines
The obvious question here is how the OVP hardware knows about the new voltage and why we're bodging this in the regulator core rather than in the OVP hardware.
Quoted 7 lines
Quoted 4 lines
The OVP hardware is part of the regulator and the regulator is not notified directly about voltage changes. The regulator transforms the PWM input into DC output and does the OVP internally with the limits described above.
So the PWM is just configuring this external regulator chip (which doesn't seem to be described in DT...)
Exactly
Quoted 1 line
and that's just incredibly bad at coping with voltage changes?
Supposedly OVP is a feature of the chip, but it gets in our way on "larger" voltage changes.
Quoted 2 lines
It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
Ok, we'll consider this. It seems we can drop this patch since the regulator core is not the best place to address this problem.
Thanks for your reviews!
Matthias
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 7 lines · Matthias Kaehlcke
El Fri, Sep 16, 2016 at 05:32:53PM +0100 Mark Brown ha dit:
Quoted 2 lines
It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
Ok, we'll consider this. It seems we can drop this patch since the regulator core is not the best place to address this problem.
Perhaps it is, perhaps it isn't - the above is a question about how we describe this stuff.
Hi,
Quoted 12 lines · Mark Brown
Quoted 10 lines · Matthias Kaehlcke
El Thu, Sep 15, 2016 at 03:39:45PM +0100 Mark Brown ha dit:
Quoted 3 lines
The obvious question here is how the OVP hardware knows about the new voltage and why we're bodging this in the regulator core rather than in the OVP hardware.
The OVP hardware is part of the regulator and the regulator is not notified directly about voltage changes. The regulator transforms the PWM input into DC output and does the OVP internally with the limits described above.
Quoted 4 lines
So the PWM is just configuring this external regulator chip (which doesn't seem to be described in DT...) and that's just incredibly bad at coping with voltage changes? It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
I'm not 100% sure you can blame the regulator chip. What we describe in the device tree as a "PWM Regulator" is actually:
1. Some discreet buck regulator whose output voltage is configured by adjusting an input voltage. AKA: the buck regulator has "3" inputs:
vin, vout, config. You put a certain voltage on the "config" pin and that controls the value that comes out of "vout".
2. A network of resistors, capacitors, and inductors that take the output of a PWM and filter / smooth it enough that it can be a good config input to the discreet buck.
The actual behavior of the PWM regulator depends as much (or more) on what values you have for the resistors, capacitors, and inductors than it does on the actual buck. ...so two people using the same discreet buck might have very different behaviors in terms of rise time and how much they are impacted by the over voltage protection.
-Doug
Mark Brown
maintainerQuoted 10 lines · Doug Anderson
Quoted 4 lines · Mark Brown
So the PWM is just configuring this external regulator chip (which doesn't seem to be described in DT...) and that's just incredibly bad at coping with voltage changes? It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
I'm not 100% sure you can blame the regulator chip. What we describe in the device tree as a "PWM Regulator" is actually:
Quoted 8 lines
1. Some discreet buck regulator whose output voltage is configured by adjusting an input voltage. AKA: the buck regulator has "3" inputs:
vin, vout, config. You put a certain voltage on the "config" pin and that controls the value that comes out of "vout".2. A network of resistors, capacitors, and inductors that take the output of a PWM and filter / smooth it enough that it can be a good config input to the discreet buck.
Ugh, right. So you're using the PWM regulator output voltage as an input to this other regulator. TBH that sounds even more like this other regulator should be represented in DT as the consumer of the PWM regulator, the PWM regulator is not actually producing the voltages claimed directly.
Quoted 5 lines
The actual behavior of the PWM regulator depends as much (or more) on what values you have for the resistors, capacitors, and inductors than it does on the actual buck. ...so two people using the same discreet buck might have very different behaviors in terms of rise time and how much they are impacted by the over voltage protection.
Right, these are properties of the PWM regulator. But for some reason the DCDC is still incapable of understanding it's own transitions and flags out of spec too easily? That isn't really a sign of high quality, but then this does seem like the DCDC is really intended for a fixed voltage application and is being abused in this system design to scale dynamically so really it's a badly concieved hardware design I suppose.
Hi,
Quoted 20 lines · Mark Brown
Quoted 10 lines · Doug Anderson
Quoted 4 lines · Mark Brown
So the PWM is just configuring this external regulator chip (which doesn't seem to be described in DT...) and that's just incredibly bad at coping with voltage changes? It does sound rather like we ought to be representing this chip directly in case it needs other workarounds.
I'm not 100% sure you can blame the regulator chip. What we describe in the device tree as a "PWM Regulator" is actually:
Quoted 8 lines
1. Some discreet buck regulator whose output voltage is configured by adjusting an input voltage. AKA: the buck regulator has "3" inputs:
vin, vout, config. You put a certain voltage on the "config" pin and that controls the value that comes out of "vout".2. A network of resistors, capacitors, and inductors that take the output of a PWM and filter / smooth it enough that it can be a good config input to the discreet buck.
Quoted 5 lines
Ugh, right. So you're using the PWM regulator output voltage as an input to this other regulator. TBH that sounds even more like this other regulator should be represented in DT as the consumer of the PWM regulator, the PWM regulator is not actually producing the voltages claimed directly.
I guess I think of the whole network of components as the PWM regulator and not the individual discreet BUCK. I'm also not quite sure how you would model it as you're asking. I suppose you could say that all of the resistors / capacitors / inductors end up producing a voltage and this voltage is an input to the BUCK. ...then the BUCK looks as the voltage on this control input and uses that to decide how to convert VIN to VOUT. That's sorta how I think about it, but I _think_ it's more intertwined than that. Looking at the schematics there are plenty of connections from the output voltage back to the PWM (through various discreets). I really think you can't model it as two distinct things: this whole glom of stuff is one beast.
I know for sure that our EEs have massively modified the behavior of the whole thing by just changing the resistors / capacitors / inductors, changing the undershoot, OVP issue, voltage ranges, default voltage, etc. That's what leads me to believe it's not so separable.
You could possible include some sort of string indicating what the model of the BUCK is, but I'm not sure how you would use it at the moment.
Quoted 6 lines
Quoted 5 lines
The actual behavior of the PWM regulator depends as much (or more) on what values you have for the resistors, capacitors, and inductors than it does on the actual buck. ...so two people using the same discreet buck might have very different behaviors in terms of rise time and how much they are impacted by the over voltage protection.
Quoted 6 lines
Right, these are properties of the PWM regulator. But for some reason the DCDC is still incapable of understanding it's own transitions and flags out of spec too easily? That isn't really a sign of high quality, but then this does seem like the DCDC is really intended for a fixed voltage application and is being abused in this system design to scale dynamically so really it's a badly concieved hardware design I suppose.
Yes, it's not ideal hardware. :( I wish we could change it to avoid this, but at this point I think we're stuck with it.
As I heard it described, the whole PWM regulator concept allows you to take relatively low cost BUCKs and make them easy to adjust up or down in software. It may have its downsides, but if it is inexpensive and can be made to work by adding a few delays for downward transitions I have a feeling that people will want to use it.
-Doug
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 5 lines · Doug Anderson
I guess I think of the whole network of components as the PWM regulator and not the individual discreet BUCK. I'm also not quite sure how you would model it as you're asking. I suppose you could say that all of the resistors / capacitors / inductors end up producing a voltage and this voltage is an input to the BUCK. ...then the BUCK
Yes, that's what's happening.
Quoted 4 lines
I know for sure that our EEs have massively modified the behavior of the whole thing by just changing the resistors / capacitors / inductors, changing the undershoot, OVP issue, voltage ranges, default voltage, etc. That's what leads me to believe it's not so separable.
What you're describing to me is a discrete DCDC that has an input voltage that sets the output voltage which happens to be set with a PWM. It's of course going to be the case that the passives are important to the system performance but it seems we have two bits here - the PWM regulator providing an input to the DCDC and the DCDC itself which is sensitive to rate changes.
Quoted 3 lines
You could possible include some sort of string indicating what the model of the BUCK is, but I'm not sure how you would use it at the moment.
Well, the main thing it's apparently doing is providing this over
voltage protection... That's the bit that seems to warrant being
captured in this separate device.
Quoted 5 lines
As I heard it described, the whole PWM regulator concept allows you to take relatively low cost BUCKs and make them easy to adjust up or down in software. It may have its downsides, but if it is inexpensive and can be made to work by adding a few delays for downward transitions I have a feeling that people will want to use it.
If they were easy to adjust up or down in software there wouldn't be any issue! There doesn't seem to be anything PWM specific in the false positive OVP issue, we could equally imagine someone shoving a regulator like this on an otherwise unused LDO and experiencing the same problem. The fact that a PWM is being used to generate the input voltage seems like just a decision this particular system took to pair a cheap controllable regualator with a not quite system appropriate high current regulator, if this pattern does start to get wider use I'd expect to see other systems using other regulators to set the input voltage.
El Fri, Oct 28, 2016 at 07:15:21PM +0100 Mark Brown ha dit:
Quoted 15 lines · Doug Anderson
Quoted 6 lines
I guess I think of the whole network of components as the PWM regulator and not the individual discreet BUCK. I'm also not quite sure how you would model it as you're asking. I suppose you could say that all of the resistors / capacitors / inductors end up producing a voltage and this voltage is an input to the BUCK. ...then the BUCK
Yes, that's what's happening.
Quoted 4 lines
I know for sure that our EEs have massively modified the behavior of the whole thing by just changing the resistors / capacitors / inductors, changing the undershoot, OVP issue, voltage ranges, default voltage, etc. That's what leads me to believe it's not so separable.
Quoted 6 lines
What you're describing to me is a discrete DCDC that has an input voltage that sets the output voltage which happens to be set with a PWM. It's of course going to be the case that the passives are important to the system performance but it seems we have two bits here - the PWM regulator providing an input to the DCDC and the DCDC itself which is sensitive to rate changes.
I experimented a bit with this. Besides the question of how to model the passives I wonder how the two regulators would interact. The correct thing seems to be to specify the input regulator as a supply of the DCDC. dcdc->set_voltage breaks down a voltage transition into steps (if needed) and calls regulator_set_voltage(supply) for each step. The problem with that is that regulator_set_voltage(dcdc) acquires the supply lock(s), later regulator_set_voltage(supply) tries to acquire its own lock which is already held. This can be worked around by only using the supply regulator in the DCDC, but not specify it as a supply. However this seems more a hack than a proper solution.
Am I missing something obvious here or approaching this from a wrong angle?
Thanks
Matthias
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Mark Brown
maintainerQuoted 10 lines · Matthias Kaehlcke
El Fri, Oct 28, 2016 at 07:15:21PM +0100 Mark Brown ha dit:
Quoted 4 lines · Doug Anderson
What you're describing to me is a discrete DCDC that has an input voltage that sets the output voltage which happens to be set with a PWM.
I experimented a bit with this. Besides the question of how to model the passives I wonder how the two regulators would interact. The correct thing seems to be to specify the input regulator as a supply of the DCDC.
dcdc->set_voltagebreaks down a voltage transition into
No, not unless the prior descriptions of the hardware have been wildly inaccurate - my understanding had been that the DCDC was a normal DCDC with an analogue input intended to be biased to set the output voltage (presumably in terms of a full rail supply) and that the PWM had been connected to this analogue input. If the PWM is supplying the DCDC then the hardware design just seems bizzare, I can't see how this would even work.
Hi,
Quoted 12 lines · Mark Brown
Quoted 10 lines · Matthias Kaehlcke
El Fri, Oct 28, 2016 at 07:15:21PM +0100 Mark Brown ha dit:
Quoted 4 lines · Doug Anderson
What you're describing to me is a discrete DCDC that has an input voltage that sets the output voltage which happens to be set with a PWM.
I experimented a bit with this. Besides the question of how to model the passives I wonder how the two regulators would interact. The correct thing seems to be to specify the input regulator as a supply of the DCDC.
dcdc->set_voltagebreaks down a voltage transition into
Quoted 7 lines
No, not unless the prior descriptions of the hardware have been wildly inaccurate - my understanding had been that the DCDC was a normal DCDC with an analogue input intended to be biased to set the output voltage (presumably in terms of a full rail supply) and that the PWM had been connected to this analogue input. If the PWM is supplying the DCDC then the hardware design just seems bizzare, I can't see how this would even work.
Looking at one schematic, the discrete BUCK for at least one of the rails is TPS65261RHBR, which appears to be described at
<https://store.ti.com/TPS65261RHBR.aspx>. Data sheet appears to be at
<http://www.ti.com/product/tps65261/technicaldocuments?HQS=TI-null-null-octopart-df-pf-null-wwe>.
As you can see from the datasheet ("Adjusting the Output Voltage" section), it is intended that you stuff a resistor to make a voltage divider and that's how you select the output voltage. In our case the PWM interacts here and allows you to make a more dynamic output voltage. I've always thought about the input to the "FB" pin as making an input voltage, but I guess it's not terribly simple since the voltage divider ends up dividing between ground and the output voltage.
Also as you can see, the datasheet never talks about using a PWM to control the feedback and as I understand it the BUCK wasn't designed for this, but it (mostly) works just fine.
...you can also see details about the Over Voltage Protection (at last for this BUCK) in the TPS65261RHBR datasheet.
-Doug
Hi,
El Tue, Dec 13, 2016 at 12:00:32PM -0800 Doug Anderson ha dit:
Quoted 26 lines · Mark Brown
Quoted 12 lines · Matthias Kaehlcke
Quoted 10 lines
El Fri, Oct 28, 2016 at 07:15:21PM +0100 Mark Brown ha dit:
Quoted 4 lines · Doug Anderson
What you're describing to me is a discrete DCDC that has an input voltage that sets the output voltage which happens to be set with a PWM.
I experimented a bit with this. Besides the question of how to model the passives I wonder how the two regulators would interact. The correct thing seems to be to specify the input regulator as a supply of the DCDC.
dcdc->set_voltagebreaks down a voltage transition intoQuoted 7 lines
No, not unless the prior descriptions of the hardware have been wildly inaccurate - my understanding had been that the DCDC was a normal DCDC with an analogue input intended to be biased to set the output voltage (presumably in terms of a full rail supply) and that the PWM had been connected to this analogue input. If the PWM is supplying the DCDC then the hardware design just seems bizzare, I can't see how this would even work.
Looking at one schematic, the discrete BUCK for at least one of the rails is TPS65261RHBR, which appears to be described at
<https://store.ti.com/TPS65261RHBR.aspx>. Data sheet appears to be at
<http://www.ti.com/product/tps65261/technicaldocuments?HQS=TI-null-null-octopart-df-pf-null-wwe>.
Quoted 8 lines
As you can see from the datasheet ("Adjusting the Output Voltage" section), it is intended that you stuff a resistor to make a voltage divider and that's how you select the output voltage. In our case the PWM interacts here and allows you to make a more dynamic output voltage. I've always thought about the input to the "FB" pin as making an input voltage, but I guess it's not terribly simple since the voltage divider ends up dividing between ground and the output voltage.
I also had put my mind on seeing the output of the PWM circuitry as an input voltage, but technically it isn't a supply of the buck regulator. It seems we could consider it a "control voltage" instead and thus avoid the recursive lock acquisition.
Matthias
Mark Brown
maintainerQuoted 10 lines · Doug Anderson
Quoted 7 lines · Mark Brown
No, not unless the prior descriptions of the hardware have been wildly inaccurate - my understanding had been that the DCDC was a normal DCDC with an analogue input intended to be biased to set the output voltage (presumably in terms of a full rail supply) and that the PWM had been connected to this analogue input. If the PWM is supplying the DCDC then the hardware design just seems bizzare, I can't see how this would even work.
Quoted 3 lines
As you can see from the datasheet ("Adjusting the Output Voltage" section), it is intended that you stuff a resistor to make a voltage divider and that's how you select the output voltage. In our case the
OK, that's what I thought was happening. That's definitely something that should *not* end up in ->supply, that should hold the parent supply that the DCDC is regulating down to the target voltage.