tree 7dc7fbb0bf60fb5cf5c1ea97b5c21f39b2342851
parent 807acd7d71382a33fad28beb8335c1acb0d733bc
author Duncan Laurie <dlaurie@google.com> 1484841295 -0800
committer chrome-bot <chrome-bot@chromium.org> 1484899507 -0800

Revert "flashchips: Update hardware sequencing and W25Q128 entries"

This reverts commit f2b2dab1236a225d735a3e9ab0cd53f479b950e3.

Reason for revert: breaks existing boards

BUG=chrome-os-partner:62116,chrome-os-partner:62117
TEST=tested manually built flashrom with commits reverted

Signed-off-by: Duncan Laurie <dlaurie@chromium.org>

Original change's description:
> flashchips: Update hardware sequencing and W25Q128 entries
>
> The Winbond W25Q128 series chips and Intel hardware sequencing have
> a bit of an interesting/confusing history. This patch attempts to
> straighten things out.
>
> Some background:
> - Support for some W25Q128 parts imported from upstream a long time ago.
> - W25Q128FW was added for Smaug. W25Q128FW is a 1.8V variant which
>   shares model ID with some uncommon 3.3V variants of the W25Q128
>   (including the W25Q128FV operating in QPI mode).
> - To further confuse things, when hardware sequencing for Apollo
>   Lake (Reef) was added, we hardcoded "W25Q128.V" as the name of
>   the chip. This was intended to account for some variants, but the
>   platform which uses this method (Reef) actually has a W25Q128FW
>   like Smaug.
>
> This patch makes the cosmetic change to the original W25Q128 entry
> so that it shows "W25Q128.V" as the name when it's found, indicating
> a possible match for W25Q128BV, W25Q128FV (SPI mode), or W25Q128JV.
>
> The follow-up patch will make it so that platforms which use hardware
> sequencing (e.g. Reef) will correctly identify the chip. For Reef, this
> will result in "flashrom -p host --flash-name" returning "W25Q128FW"
> instead of "W25Q128.V".
>
> This patch opportunistically adds missing attributes to the W25Q128FW
> entry, namely the OTP feature bit and voltage. The voltage attribute
> is set to 1.8V for now. It's a bit unfortunate since that might
> make things difficult for users of the other variants which share the
> same model ID. They may need to specify voltage on the command-line
> or create a duplicate entry with a different name that can be
> specified using "-c" on the command-line.
>
> BUG=chrome-os-partner:57193
> CQ-DEPEND=CL:423178
> BRANCH=none
> TEST=tested with follow-up patch
>
> Change-Id: Id1913eb7377ca5c6aadced4e148d2d20b813a013
> Signed-off-by: David Hendricks <dhendrix@chromium.org>
> Reviewed-on: https://chromium-review.googlesource.com/423177
> Reviewed-by: Hung-Te Lin <hungte@chromium.org>
>

TBR=hungte@chromium.org,dhendrix@chromium.org,martinroth@chromium.org,phoenixshen@chromium.org
BUG=chrome-os-partner:57193

Change-Id: I0bee6803db923214623fbebd3191055d59cbea0a
Reviewed-on: https://chromium-review.googlesource.com/430305
Commit-Ready: Dan Shi <dshi@chromium.org>
Tested-by: Duncan Laurie <dlaurie@google.com>
Reviewed-by: Benson Leung <bleung@chromium.org>
