tree d3bd6e99e74d244fea55cb328069b89796af5c33
parent 153e66f5136bc5b33db253ad2db011177196626e
author Lars-Peter Clausen <lars@metafoo.de> 1389445341 +0100
committer Mark Brown <broonie@linaro.org> 1389734919 +0000

ASoC: samsung: Remove SND_DMAENGINE_PCM_FLAG_NO_RESIDUE flag

The Samsung dmaengine ASoC driver is used with two different dmaengine drivers.
The pl80x, which properly supports residue reporting and the pl330, which
reports that it does not support residue reporting. So there is no need to
manually set the NO_RESIDUE flag. This has the advantage that a proper (race
condition free) PCM pointer() implementation is used when the pl80x driver is
used. Also once the pl330 driver supports residue reporting the ASoC PCM driver
will automatically start using it.

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