tree 9db3361527e295c6a4eb68caa3960c4fa90d4150
parent 727ee667561909ecb05a2671bd7d885aa111cd60
author Felix Held <felix-coreboot@felixheld.de> 1703108855 +0100
committer Shelley Chen <shchen@google.com> 1703611302 +0000

soc/amd/common/pi/agesawrapper: use is_dev_enabled(DEV_PTR())

Since we have chipset devicetrees for all SoCs that include this code in
the build, we can use the DEV_PTR macro instead of using
pcidev_path_on_root to get the device struct pointer. We can also use
the is_dev_enabled function instead of checking the value of the enabled
element of the device struct directly.

Signed-off-by: Felix Held <felix-coreboot@felixheld.de>
Change-Id: I5dcd92399e2d3f304352f2170dd3ef8761e86541
Reviewed-on: https://review.coreboot.org/c/coreboot/+/79672
Reviewed-by: Felix Singer <service+coreboot-gerrit@felixsinger.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
