tree abcf1479206a3d7348ff98c5001de8bd16136297
parent e0b92e0c8e88b19ed53c28ec71e3dd585f4b96dc
author Christopher Lentocha <christopherericlentocha@gmail.com> 1674063378 -0500
committer Nico Huber <nico.h@gmx.de> 1678838356 +0000

Add missing Intel B460 flash chip id

Note that while I can read the chip, on my Lenovo Legion T5 28IMB05,
cannot write to the flash chip with any tools except upgrading with
vendor tool, no downgrades are allowed, due to the fact of SMM, even if
I did manage to flash the BIOS chip somehow, would still face bootguard
since this machine has bootguard. But if I read the chip, and verify my
read bin file, it works fine, until changing the SMBIOS, which is in
the vendor BIOS update package.

flashrom-stable:
Marked as DEP as that is the convention for config-dependent chipsets.

Change-Id: Id8fcb59d5dbafea3e79c4e3ad75484bbd163feca
Signed-off-by: Christopher Lentocha <christopherericlentocha@gmail.com>
Original-Reviewed-on: https://review.coreboot.org/c/flashrom/+/72056
Original-Reviewed-by: Thomas Heijligen <src@posteo.de>
Original-Reviewed-by: Paul Menzel <paulepanter@mailbox.org>
Reviewed-on: https://review.coreboot.org/c/flashrom-stable/+/73486
Reviewed-by: Nico Huber <nico.h@gmx.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
