tree b7abe5d7bf55f22b0cc1f6226c2c21c0e8dcf04e
parent d7b54c3083b2e04243697c5e450a446d501107bc
author Kevin Strasser <kevin.strasser@intel.com> 1400487263 +0300
committer Mark Brown <broonie@linaro.org> 1400517056 +0100

ASoC: Intel: Fix pcm stream context restore crash

In some cases the pcm stream is closed while context has been
scheduled to be restored, causing a null pointer deref panic.
Cancel work to ensure stream does not get freed while work is
still active/pending.

Also, restoring the pcm context can be safely skipped after the
stream has been stopped. Check if pcm stream is still running
before restoring stream context to help pending work finish
more quickly in stream close path.

Signed-off-by: Kevin Strasser <kevin.strasser@intel.com>
Signed-off-by: Jarkko Nikula <jarkko.nikula@linux.intel.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
