tree 7e9d66a9de74c6d55a81f29e2a32d801884807b2
parent 00ef7661ff46f68e1c3d882476f30e4cac8181c0
author Matt Spinler <spinler@us.ibm.com> 1591114588 -0500
committer Matt Spinler <spinler@us.ibm.com> 1594820614 +0000

gen_path_callouts: Create multi-segment callouts

The BMC FSI segments will be connected to other FSI segments to create
new FSI callouts as far out as there is a path, and all the FSI callouts
will be connected with any I2C or SPI segments to create new FSII2C or
FSISPI callouts.  For example, there could be a Callout object that
contains the path of: BMC -> FSI -> Proc -> FSI -> Proc -> I2C ->
end device.

When the new Callout objects are created from two other callout objects,
the FRU callout lists will be cumulative.  In a future commit, they will
be sorted and made unique.

Signed-off-by: Matt Spinler <spinler@us.ibm.com>
Change-Id: Id1aeb02ead755a876a25f28341c4693762b8b86a
