tree 4009015305b7d3b28ba3100b8dc3f5a3ba18b521
parent e81104643d4f62c6d4c74af8efb279ec2b9b1add
author Gwendal Grignou <gwendal@chromium.org> 1566749830 +0000
committer Gwendal Grignou <gwendal@chromium.org> 1566793979 +0000

Revert "UPSTREAM: mmc: mmc: do not use CMD13 to get status after speed mode switch"

This reverts commit 63128ee66b07ff0e5532bba3aad6797b780c663e.

Reason for revert: 
It triggers a regression where Hynix eMMC needs to be power cycled.
    
BUG=chromium:997389,b:138033787
TEST=Compile ToT Bob without it, able to install R78.
 
Original change's description:
> UPSTREAM: mmc: mmc: do not use CMD13 to get status after speed mode switch
> 
> Per JEDEC spec, it is not recommended to use CMD13 to get card status
> after speed mode switch. below are two reason about this:
> 1. CMD13 cannot be guaranteed due to the asynchronous operation.
> Therefore it is not recommended to use CMD13 to check busy completion
> of the timing change indication.
> 2. After switch to HS200, CMD13 will get response of 0x800, and even the
> busy signal gets de-asserted, the response of CMD13 is aslo 0x800.
> 
> BUG=b:138033787
> TEST=compile
> 
> Signed-off-by: Chaotian Jing <chaotian.jing@mediatek.com>
> Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
> (cherry picked from commit 08573eaf1a70104f83fdbee9b84e5be03480e9ed)
> 
> 
> Change-Id: I32935cffeae3e89b658bfd7b8260f7f09b726793
> Signed-off-by: Gwendal Grignou <gwendal@chromium.org>
> Reviewed-on: https://chromium-review.googlesource.com/1716943
> Legacy-Commit-Queue: Commit Bot <commit-bot@chromium.org>
> Reviewed-by: Douglas Anderson <dianders@chromium.org>
> Reviewed-by: Sean Paul <seanpaul@chromium.org>
> (cherry picked from commit 1392a26757ce4b1770754dacb4dbbb9666b63ce0)
> 
> Signed-off-by: Tim Chen <tim-chen@quanta.corp-partner.google.com>
> Cq-Depend: chromium:1727139
> Change-Id: I32935cffeae3e89b658bfd7b8260f7f09b726793
> Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/kernel/+/1753485
> Reviewed-by: Vincent Wang <vwang@chromium.org>
> Reviewed-by: Douglas Anderson <dianders@chromium.org>
> Reviewed-by: Sean Paul <seanpaul@chromium.org>

Bug: b:138033787
Change-Id: I5051d9163ccf0a33891a61534738bae694da88ee
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/kernel/+/1770858
Tested-by: Gwendal Grignou <gwendal@chromium.org>
Reviewed-by: Gwendal Grignou <gwendal@chromium.org>
Commit-Queue: Gwendal Grignou <gwendal@chromium.org>
