tree a7aee791d053a1cd6ee4c2b62279733ffe932667
parent 7866193eeeab79c5a1b6b8cd1e024fece5dc7d82
author Johnny Li <johnny_li@wistron.corp-partner.google.com> 1671527390 +0800
committer Martin L Roth <gaumless@gmail.com> 1671924944 +0000

mb/google/volteer/eldrid: Correct DDR4 SPDs for Eldrid

Correct DDR4 SPDs from H5AG36EXNDX019 to H5AG36EXNDX017.

DRAM Part Name    ID to assign
H5AG36EXNDX017    0 (0000)

BUG=b:236739240
BRANCH=Volteer
TEST="FW_NAME=eldrid emerge-volteer coreboot" and verify it builds successfully.

Signed-off-by: Johnny Li <johnny_li@wistron.corp-partner.google.com>
Change-Id: If248714088835eb5dd48fa12223c273199297228
Reviewed-on: https://review.coreboot.org/c/coreboot/+/71160
Reviewed-by: Tarun Tuli <taruntuli@google.com>
Reviewed-by: Zhuohao Lee <zhuohao@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
