tree 8b5dcf0d475476da3ee8c2cb310e9bce34e6d30a
parent 272b98c6455f00884f0350f775c5342358ebb73f
author Laxman Dewangan <ldewangan@nvidia.com> 1379508482 +0530
committer Mark Brown <broonie@linaro.org> 1379520782 +0100

regulator: core: add support for configuring turn-on time through constraints

The turn-on time of the regulator depends on the regulator device's
electrical characteristics. Sometimes regulator turn-on time also
depends on the capacitive load on the given platform and it can be
more than the datasheet value.

The driver provides the enable-time as per datasheet.

Add support for configure the enable ramp time through regulator
constraints so that regulator core can take this value for enable
time for that regulator.

Signed-off-by: Laxman Dewangan <ldewangan@nvidia.com>
Acked-by: Stephen Warren <swarren@nvidia.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
