tree 813298ecd709a229dba9cdc5864f78f2b5f670a0
parent b33816e171ad111bd089979427a5eaaf6890a3f0
author Peter Marheine <pmarheine@chromium.org> 1630640046 +1000
committer Edward O'Callaghan <quasisec@chromium.org> 1630977877 +0000

documentation: add a section on devicetree refs

There is no existing documentation on how `device ref` and aliases work
in the devicetree, and the behavior around devices not being in the same
location is difficult to discern as well as somewhat unexpected.

This should help prevent confusion leading to bugs such as the one fixed
by https://review.coreboot.org/c/coreboot/+/57298

Change-Id: I4b30f7d531cfc3453d6523a76084f1969125b4bf
Signed-off-by: Peter Marheine <pmarheine@chromium.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/57354
Reviewed-by: Edward O'Callaghan <quasisec@chromium.org>
Reviewed-by: Angel Pons <th3fanbus@gmail.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
