tree ef94a414cb3c36cb29ce045afe2a7b3a345471f9
parent eb1a2bd1325d1f783a8062a4a762843dc75d4869
author Felix Singer <felixsinger@posteo.net> 1698074134 +0200
committer Felix Held <felix-coreboot@felixheld.de> 1698243771 +0000

mb/hp/280_g2/devicetree: Use comma separated list for arrays

In order to improve the readability of the settings, use a comma
separated list to assign values to their indexes instead of repeating
the option name for each index.

Don't convert the settings for PCIe root ports as they should stay in
the devicetree at their related root ports.

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