tree 8aa8ea7a6543cec8734b3ad63a807aee6bf259c0
parent 1b56ecfecbd9993680539fdc2be358b23cc3d6a3
author Bard Liao <bardliao@realtek.com> 1451974931 +0800
committer ChromeOS bot <3su6n15k.default@developer.gserviceaccount.com> 1453437894 +0000

UPSTREAM: ASoC: rt5645: improve IRQ reaction time for HS button

IRQ reaction time is not immediate when headset button is pressed.
This patch shortens the reaction time.

Signed-off-by: John Lin <john.lin@realtek.com>
Signed-off-by: Bard Liao <bardliao@realtek.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
(cherry picked from commit 15b0f4d4b169dde8ecc4e162bcd6cd145cb09fed,
 https://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git)

BUG=chrome-os-partner:48522
TEST=use evtest to verify headset button

Change-Id: I42b7e5d5858fbce67220a889a0d992d5dcdb928e
Reviewed-on: https://chromium-review.googlesource.com/322575
Commit-Ready: John Lin <john.lin@realtek.com>
Tested-by: John Lin <john.lin@realtek.com>
Reviewed-by: John Lin <john.lin@realtek.com>
Reviewed-by: Dylan Reid <dgreid@chromium.org>
(cherry picked from commit e0862a28cad49b5627d65efefb5756d5bdd5d97e)
Reviewed-on: https://chromium-review.googlesource.com/320501
Commit-Queue: John Lin <john.lin@realtek.com>
Reviewed-by: Cheng-Yi Chiang <cychiang@chromium.org>
