tree fb8dd4397f57e87488d14e0247783b42aacabca1
parent 4b52fa211a7c65eab78acf3f434361d40de87688
author Lars-Peter Clausen <lars@metafoo.de> 1377611460 +0200
committer Mark Brown <broonie@linaro.org> 1377614383 +0100

ASoC: Move call to snd_soc_dapm_new_widgets() after snd_soc_dapm_auto_nc_codec_pins()

Call snd_soc_dapm_new_widgets() before the auto non-connected pins have been
marked as not connected will power the system under the assumption that those
pins are connected. Once the pins have been marked as disconnected the system
there will be an additional power run. This can cause unnecessary power
transitions. Calling snd_soc_dapm_new_widgets() only after the pins have been
marked as non-connected avoids this.

Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Mark Brown <broonie@linaro.org>
