tree 1f3fd1808e8c7eb50185487186f42b13f893c4c7
parent 23607025303af6e84bc2cd4cabe89c21f6a22a3f
author Liam Girdwood <liam.r.girdwood@linux.intel.com> 1389978236 +0000
committer Mark Brown <broonie@linaro.org> 1389981381 +0000

ASoC: compress: Add suport for DPCM into compressed audio

Currently compressed audio streams are statically routed from the /dev
to the DAI link. Some DSPs can route compressed data to multiple BE DAIs
like they do for PCM data.

Add support to allow dynamically routed compressed streams using the existing
DPCM infrastructure. This patch adds special FE versions of the compressed ops
that work out the runtime routing.

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>
Acked-by: Vinod Koul <vinod.koul@intel.com>
Signed-off-by: Mark Brown <broonie@linaro.org>
