tree 24426dfaa1e49f350bbad9c0407d68b4efce1514
parent 7b78a805da0207449c5ea1baf56030ab9f54e2d6
author Huayang Duan <huayang.duan@mediatek.com> 1537968233 +0800
committer Patrick Georgi <pgeorgi@google.com> 1546554178 +0000

mediatek/mt8183: Add DDR driver of memory test part

Write a range of memory with special pattern, and read it back to check
whether the read value same as write.
The test pattern include 8bit offset read write, 16 bit offset read
write, 32bit offset read write, and cross testing.

BUG=b:80501386
BRANCH=none
TEST=Boots correctly on Kukui, and inits DRAM successfully with related
     patches.

Change-Id: I30d5fbd3db2acf36e3058ba4f34558b981fba78c
Signed-off-by: Huayang Duan <huayang.duan@mediatek.com>
Reviewed-on: https://review.coreboot.org/c/28845
Reviewed-by: Hung-Te Lin <hungte@chromium.org>
Reviewed-by: You-Cheng Syu <youcheng@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
