tree 1d815822f2928e2b28622bcd0c204789277a6996
parent a87ab39817ce15ad88243ae3be830016a0f7d714
author Nina Wu <nina-cm.wu@mediatek.corp-partner.google.com> 1701248459 +0800
committer Felix Held <felix-coreboot@felixheld.de> 1701708513 +0000

soc/mediatek/mt8188: devapc: Allow APU to access BND_NORTH_APB2_S

Update BND_NORTH_APB2_S's domain 5 permission to allow the access from
APU. The APU requires certain information saved in BND_NORTH_APB2_S for
voltage tuning. If this information cannot be retrieved, the APU may
operate at a high frequency with low voltage. Consequently, the APU may
not function as expected.

Change-Id: I967b138dc5517e54da7fbf94b9e502e478c991b5
Signed-off-by: Nina Wu <nina-cm.wu@mediatek.com>
Signed-off-by: Jason Chen <Jason-ch.Chen@mediatek.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/79348
Reviewed-by: Yu-Ping Wu <yupingso@google.com>
Reviewed-by: Yidi Lin <yidilin@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
