tree e701ada1c45b2f15064674c0ae5bbf5aea68b279
parent 6ff33f3902c3b1c5d0db6b1e2c70b6d76fba357f
author Boris Brezillon <boris.brezillon@free-electrons.com> 1442828008 +0200
committer Mark Brown <broonie@kernel.org> 1442869878 -0700

regulator: pwm: implement ->enable(), ->disable() and ->is_enabled methods

Implement the ->enable(), ->disable() and ->is_enabled methods and remove
the PWM call in ->set_voltage_sel().
This is particularly important for critical regulators tagged as always-on,
because not claiming the PWM (and its dependencies) might lead to
unpredictable behavior (like a system hang because the PWM clk is only
claimed when the PWM device is enabled).

Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
