gen_devtree.pl

#!/usr/bin/env perl

#Generates a BMC device tree syntax file from the machine
#readable workbook.

use strict;
use XML::Simple;
use mrw::Targets;
use Getopt::Long;

use constant VERSION => "/dts-v1/;";
use constant STANDALONE_PROPERTY => "standalone_property";
use constant DTSI_INCLUDE => "DTSI_INCLUDE";

my $serverwizFile;
my $outputFile;
my $debug;

GetOptions("x=s" => \$serverwizFile,
           "o=s" => \$outputFile,
           "d" => \$debug)
or printUsage();

if ((not defined $serverwizFile) || (not defined $outputFile)) {
    printUsage();
}

my $g_targetObj = Targets->new;
$g_targetObj->loadXML($serverwizFile);

my $g_bmc = getBMCTarget();
if (length($g_bmc) == 0) {
    die "Unable to find a BMC in this system\n";
}

my $g_bmcModel = $g_targetObj->getAttribute($g_bmc, "MODEL");
my $g_bmcMfgr = $g_targetObj->getAttribute($g_bmc, "MANUFACTURER");
my $g_systemName = $g_targetObj->getSystemName();

open (my $f, ">$outputFile") or die "Could not open $outputFile\n";

printVersion($f);
printIncludes($f, 0);
printRootNodeStart($f);

printPropertyList($f, 1, "model", getSystemBMCModel());
printPropertyList($f, 1, "compatible", getBMCCompatibles());

printNode($f, 1, "aliases", getAliases());
printNode($f, 1, "chosen", getChosen());
printNode($f, 1, "memory", getMemory($g_bmc));

printNodes($f, 1, getSpiFlashNodes());

printNode($f, 1, "leds", getLEDNode());

printRootNodeEnd($f, 0);

printNodes($f, 0, getMacNodes());
printNodes($f, 0, getUARTNodes());
printNodes($f, 0, getVuartNodes());

close $f;
exit 0;


#Returns a hash that represents the 'aliases' node.
#Will look like:
#  aliases {
#    name1 = &val1;
#    name2 = &val2;
#    ...
#  }
sub getAliases()
{
    my %aliases;
    my $name, my $val;

    #The MRW supports up to 6 name and value pairs.
    for (my $i = 1; $i <= 6; $i++) {
        my $nameAttr = "name$i";
        my $valAttr = "value$i";

        $name = $g_targetObj->getAttributeField($g_bmc, "BMC_DT_ALIASES",
                                                $nameAttr);
        if ($name ne "") {
            $val =  $g_targetObj->getAttributeField($g_bmc, "BMC_DT_ALIASES",
                                                    $valAttr);
            #The value will be printed as '&val'
            $aliases{$name} = "(alias)$val";
        }
    }

    return %aliases;
}


#Return a hash that represents the 'chosen' node
#Will look like:
#   chosen {
#      stdout-path = ...
#      bootargs = ...
#   }
sub getChosen()
{
    my $bmcStdOut = $g_targetObj->getAttributeField($g_bmc, "BMC_DT_CHOSEN",
                                                    "stdout-path");
    my $args = $g_targetObj->getAttributeField($g_bmc, "BMC_DT_CHOSEN",
                                              "bootargs");
    my %chosen;
    $chosen{"stdout-path"} = $bmcStdOut;
    $chosen{"bootargs"} = $args;
    return %chosen;
}


#Gets the nodes that represents the BMC's SPI flash chips.  They're based
#on information from the spi-master-unit end of the connection, with
#a subnode of information from the destination chip.
#On ASPEED chips, they're nested under the ahb node (Advanced
#High-performance Bus).
#Will look like:
#   ahb {
#     fmc@... {
#       reg = ...
#       #address-cells = ...
#       #size-cells = ...
#       #compatible = ...
#
#       flash@... {
#          reg = ...
#          compatible = ...
#          label = ...
# #include ...
#       }
#     }
#     spi@... {
#     ...
#     }
#   }
sub getSpiFlashNodes()
{
    my %parentNode, my %node, my @nodes;
    my $lastParentNodeName = "default";
    my $parentNodeName = "ahb";

    my $connections = findConnections($g_bmc, "SPI", "FLASH");
    if ($connections eq "") {
        print "WARNING:  No SPI flashes found connected to the BMC\n";
        return @nodes;
    }

    foreach my $spi (@{$connections->{CONN}}) {

        my %unitNode; #Node for the SPI master unit
        my %flashNode; #subnode for the flash chip itself
        my $flashNodeName = "flash";
        my $nodeLabel = "";
        my @addresses;


        #Adds a comment into the output file about the MRW connection
        #that makes up this node.  Not that {SOURCE} always represents
        #the master unit, and DEST_PARENT represents the destination
        #chip.  The destination unit {DEST} isn't usually that interesting.
        $unitNode{COMMENT} = "$spi->{SOURCE} ->\n$spi->{DEST_PARENT}";

        #These flashes are nested in the 'ahb' (an internal chip bus)
        #node in ASPEED chips.  Get the name of it here. Will default
        #to 'ahb' if not set.
        if (!$g_targetObj->isBadAttribute($spi->{SOURCE},
                                        "INTERNAL_BUS", "NA")) {
            $parentNodeName = $g_targetObj->getAttribute($spi->{SOURCE},
                                                       "INTERNAL_BUS");
            #Not going to support this unless we have to
            if ($parentNodeName != $lastParentNodeName) {
                die "ERROR: SPI master unit $spi->{SOURCE} has a " .
                    "different internal bus name $parentNodeName than " .
                    "previous name $lastParentNodeName\n";
            }
            else {
                $lastParentNodeName = $parentNodeName;
            }
        }
        else {
            print "WARNING: No INTERNAL_BUS attribute value found for " .
                  "SPI flash unit $spi->{SOURCE}. Using '$parentNodeName'\n";
        }

        #The reg base and size of the unit will be added into
        #the reg property
        my $regBase = $g_targetObj->getAttribute($spi->{SOURCE},
                                               "BMC_DT_REG_BASE");
        my $regSize = $g_targetObj->getAttribute($spi->{SOURCE},
                                               "BMC_DT_REG_SIZE");

        #There is also another memory range that goes into reg
        my %sourceRegHash = getMemory($spi->{SOURCE});

        #Insert the regBase and regSize to the memory < ... > property
        $unitNode{reg} = "< $regBase $regSize " . substr($sourceRegHash{reg}, 2);

        #usually, this will be something like 'smc' or 'spi'
        my $nodeName = "spi";
        if (!$g_targetObj->isBadAttribute($spi->{SOURCE},
                                        "BMC_DT_NODE_NAME")) {
            $nodeName = $g_targetObj->getAttribute($spi->{SOURCE},
                                                 "BMC_DT_NODE_NAME");
        }
        else {
            print "WARNING: No BMC_DT_NODE_NAME attribute value found for " .
                  "SPI flash unit $spi->{SOURCE}. Using 'spi'\n";
        }

        #now turn it into something like fmc@...
        $regBase =~ s/^0x//;
        $nodeName .= "@".$regBase;

        if (!$g_targetObj->isBadAttribute($spi->{SOURCE},
                                        "BMC_DT_COMPATIBLE")) {
            $unitNode{compatible} = $g_targetObj->
                    getAttribute($spi->{SOURCE}, "BMC_DT_COMPATIBLE");
        }
        else {
            print "WARNING: No BMC_DT_COMPATIBLE attribute found for SPI " .
                  "flash unit $spi->{SOURCE}\n";
        }

        #The flash chip has its one reg property as well
        if (!$g_targetObj->isBadAttribute($spi->{DEST_PARENT},
                                        "BMC_DT_REG_PROPERTY")) {
            $flashNode{reg} = $g_targetObj->getAttribute($spi->{DEST_PARENT},
                                                       "BMC_DT_REG_PROPERTY");
            $flashNode{reg} = "<" . $flashNode{reg} . ">";
        }
        else {
            print "WARNING: No BMC_REG_PROPERTY attribute found for SPI " .
                  "flash $spi->{DEST_PARENT}.  Using <0>.\n";
            $flashNode{reg} = "<0>";
        }

        if (!$g_targetObj->isBadAttribute($spi->{DEST_PARENT},
                                        "BMC_DT_COMPATIBLE")) {
            $flashNode{compatible} = $g_targetObj->
                    getAttribute($spi->{DEST_PARENT}, "BMC_DT_COMPATIBLE");
        }
        else {
            print "WARNING: No BMC_DT_COMPATIBLE attribute found for SPI " .
                  "flash $spi->{DEST_PARENT}\n";
        }

        if (!$g_targetObj->isBadAttribute($spi->{DEST_PARENT},
                                        "BMC_DT_LABEL_PROPERTY")) {
            $flashNode{label} = $g_targetObj->
                    getAttribute($spi->{DEST_PARENT}, "BMC_DT_LABEL_PROPERTY");
        }

        #Some flash chips have a .dtsi include to pull in more properties.
        #Future - contents of the includes could be pulled into the MRW
        #as new attributes.
        if (!$g_targetObj->isBadAttribute($spi->{DEST_PARENT},
                                        "BMC_DT_INCLUDES")) {
            my $incs = $g_targetObj->
                    getAttribute($spi->{DEST_PARENT}, "BMC_DT_INCLUDES");
            #first remove the spaces and NAs
            $incs =~ s/\s+//g;
            $incs =~ s/NA,*//g;
            $flashNode{DTSI_INCLUDE} = $incs;
        }

        #the flash subnode name also has its reg[0] appended
        #like flash@...
        @addresses = split(' ', $flashNode{reg});
        $addresses[0] =~ s/<//;
        $addresses[0] =~ s/>//;
        $flashNodeName .= "@" . $addresses[0];
        $unitNode{$flashNodeName} = { %flashNode };

        #For now, just support a chip with 1 reg value
        if (scalar @addresses == 1) {
            $unitNode{'#address-cells'} = "<1>";
            $unitNode{'#size-cells'} = "<0>";
        }
        else {
            die "ERROR:  Unsupported number of <reg> entries " .
                "in flash node $flashNodeName for SPI flash " .
                "$spi->{DEST_PARENT}.  Only 1 entry supported.\n";
        }

        #This node will end up being in an array on the parent node
        my %node;
        $node{$nodeName} = { %unitNode };
        push @nodes, { %node };
    }

    $parentNode{$parentNodeName}{nodes} = [ @nodes ];

    #There is always just one in the array
    my @finalNodes;
    push @finalNodes, { %parentNode };
    return @finalNodes;
}


#Returns a hash that represents the leds node by finding all of the
#GPIO connections to LEDs.
#Node will look like:
#   leds {
#       <ledname> {
#          gpios =  &gpio ASPEED_GPIO(x, y) GPIO_ACTIVE_xxx>
#       };
#       <another ledname> {
#       ...
#   }
sub getLEDNode()
{
    my %leds;

    $leds{compatible} = "gpio-led";

    my $connections = findConnections($g_bmc, "GPIO", "LED");

    if ($connections eq "") {
        print "WARNING:  No LEDs found connected to the BMC\n";
        return %leds;
    }

    foreach my $gpio (@{$connections->{CONN}}) {
        my %ledNode;

        $ledNode{COMMENT} = "$gpio->{SOURCE} ->\n$gpio->{DEST_PARENT}";

        #The node name will be the simplified LED name
        my $name = $gpio->{DEST_PARENT};
        $name =~ s/(-\d+$)//; #remove trailing position
        $name =~ s/.*\///;    #remove the front of the path

        #For now only supports ASPEED.
        if (uc($g_bmcMfgr) ne "ASPEED") {
            die "ERROR:  Unsupported BMC manufacturer $g_bmcMfgr\n";
        }
        my $num = $g_targetObj->getAttribute($gpio->{SOURCE}, "PIN_NUM");
        my $macro = getAspeedGpioMacro($num);

        #If it's active high or low
        my $state = $g_targetObj->getAttribute($gpio->{DEST_PARENT}, "ON_STATE");
        my $activeString = getGpioActiveString($state);

        $ledNode{gpios} = "<&gpio $macro $activeString>";

        $leds{$name} = { %ledNode };
    }

    return %leds;
}


#Returns a either GPIO_ACTIVE_HIGH or GPIO_ACTIVE_LOW
#  $val = either a 1 or a 0 for active high or low
sub getGpioActiveString() {
    my $val = shift;

    if ($val == 0) {
       return "GPIO_ACTIVE_LOW";
    }

    return "GPIO_ACTIVE_HIGH";
}


#Turns a GPIO number into something like ASPEED_GPIO(A, 0) for the
#ASPEED GPIO numbering scheme A[0-7] -> Z[0-7] and then starts at
#AA[0-7] after that.
#  $num = the GPIO number
sub getAspeedGpioMacro() {
    my $num = shift;
    my $char;
    my $offset = $num % 8;
    my $block = int($num / 8);

    #If past Z, wraps to AA, AB, etc
    if ((ord('A') + $block) > ord('Z')) {
        #how far past Z?
        $char = $block - (ord('Z') - ord('A'));

        #Don't let it wrap twice
        if ($char > (ord('Z') - ord('A') + 1)) {
            die "ERROR: Invalid PIN_NUM value $num found for GPIO\n";
        }

        #start back at 'A' again, and convert to a character
        $char = chr($char + ord('A') - 1);

        #Add in a bonus 'A', to get something like AB
        $char = "A".$char;
    }
    else {
        $char = ord('A') + $block;
        $char = chr($char);
    }

    return "ASPEED_GPIO($char, $offset)";
}


#Returns a list of hashes that represent the UART nodes on the BMC by
#finding the UART connections.
#Nodes will look like:
#  &uartX {
#     status = "okay"
#  }
sub getUARTNodes()
{
    my @nodes;

    #Using U750 for legacy MRW reasons
    my $connections = findConnections($g_bmc, "U750");

    if ($connections eq "") {
        print "WARNING:  No UART buses found connected to the BMC\n";
        return @nodes;
    }

    foreach my $uart (@{$connections->{CONN}}) {
        my %node;

        my $num = $g_targetObj->getAttribute($uart->{SOURCE}, "CHIP_UNIT");
        my $name = "uart$num";

        $node{$name}{status} = "okay";
        $node{$name}{COMMENT} = "$uart->{SOURCE} ->\n$uart->{DEST_PARENT}";

        push @nodes, { %node };
    }

    return @nodes;
}


#Returns a list of hashes that represent the MAC (ethernet) nodes on the BMC
#by finding the connections of type ETHERNET.
#Nodes will look like:
#  &macX {
#    ...
#  }
sub getMacNodes()
{
    my @nodes;

    my $connections = findConnections($g_bmc, "ETHERNET");

    if ($connections eq "") {
        print "WARNING:  No ethernet buses found connected to the BMC\n";
        return @nodes;
    }

    foreach my $eth (@{$connections->{CONN}}) {
        my %node;

        my $num = $g_targetObj->getAttribute($eth->{SOURCE}, "CHIP_UNIT");
        my $ncsi = $g_targetObj->getAttribute($eth->{SOURCE}, "NCSI_MODE");
        my $hwChecksum = $g_targetObj->getAttribute($eth->{SOURCE},
                                                  "USE_HW_CHECKSUM");

        my $name = "mac$num";
        $node{$name}{status} = "okay";

        if ($ncsi == 1) {
            $node{$name}{"use-ncsi"} = STANDALONE_PROPERTY;
        }
        if ($hwChecksum == 0) {
            $node{$name}{"no-hw-checksum"} = STANDALONE_PROPERTY;
        }

        $node{$name}{COMMENT} = "$eth->{SOURCE} ->\n$eth->{DEST_PARENT}";

        push @nodes, { %node };
    }

    return @nodes;
}


#Returns a list of hashes that represent the virtual UART nodes
#Node will look like:
#  &vuart {
#   status = "okay"
#  }
sub getVuartNodes()
{
    my @nodes;
    my %node;

    #For now, enable 1 node all the time.
    #TBD if this needs to be fixed
    $node{vuart}{status} = "okay";

    push @nodes, { %node };

    return @nodes;
}


#Returns a hash{'reg'} = "<.....>"  based on the
#BMC_DT_MEMORY attribute.  This is used to display
#memory ranges.
sub getMemory()
{
    my $target = shift;
    my $memory = $g_targetObj->getAttribute($target, "BMC_DT_MEMORY");
    my @mem = split(',', $memory);
    my %property;
    my $val = "< ";

    #Encoded as 4 <base address>,<size> pairs of memory ranges
    #Unused ranges are all 0s.
    #For now, assumes 32 bit numbers, revisit later for 64 bit support
    #Convert it into:  <num1 num2 num3 num4 etc>

    for (my $i = 0;$i < scalar @mem;$i += 2) {

        #pair is valid if size is nonzero
        if (hex($mem[$i+1]) != 0) {
            $val .= "$mem[$i] $mem[$i+1] ";
        }
    }

    $val =~ s/\s$//;
    $val .= " >";
    $property{reg} = $val;

    return %property;
}


#Returns a list of compatible fields for the BMC itself.
sub getBMCCompatibles()
{
    my @compats;

    #1st entry:  <system mfgr>,<system name>-bmc
    #2nd entry:  <bmc mfgr>,<bmc model>

    foreach my $target (sort keys %{ $g_targetObj->getAllTargets() }) {
        if ($g_targetObj->getType($target) eq "SYS") {
           my $mfgr = $g_targetObj->getAttribute($target, "MANUFACTURER");
           push @compats, lc "$mfgr,$g_systemName-bmc";
           last;
        }
    }

    push @compats, lc($g_bmcMfgr).",".lc($g_bmcModel);

    return @compats;
}


#Returns a string for the system's BMC model property
sub getSystemBMCModel()
{
    #'<System> BMC'
    my $sys = lc $g_systemName;
    $sys = uc(substr($sys, 0, 1)) . substr($sys, 1);

    return $sys . " BMC";
}


#Prints a list of nodes at the same indent level
#  $f = file handle
#  $level = indent level (0,1,etc)
#  @nodes = array of node hashes to print, where the
#  key for the hash is the name of the node
sub printNodes()
{
    my ($f, $level, @nodes) = @_;

    foreach my $n (@nodes) {
        my %node = %$n;

        foreach my $name (sort keys %node) {
            my %n = %{ $node{$name} };
            printNode($f, $level, $name, %n);
        }
    }
}


#Print a single node and its children
#  $f = file handle
#  $level = indent level (0,1,etc)
#  $name = the name of the node - shows up as:
#     name { ...
#  %vals = The contents of the node, with the following options:
#     if the key is:
#     - 'DTSI_INCLUDE', then value gets turned into a #include
#     - 'COMMENT', then value gets turned into a // comment
#     - 'STANDALONE_PROPERTY' then value gets turned into:  value;
#
#     If the value is:
#     - a hash - then that hash gets turned into a child node
#       where the key is the name of the child node
#     - an array of hashes indicates an array of child nodes
sub printNode()
{
    my ($f, $level, $name, %vals) = @_;
    my $include = "";

    if ($level == 0) {
        $name = "&".$name;
    }

    print $f "\n";

    if (exists $vals{COMMENT}) {
        my @lines = split('\n', $vals{COMMENT});
        foreach my $l (@lines) {
            print $f indent($level) . "// $l\n";
        }
    }

    print $f indent($level) . "$name {\n";

    foreach my $v (sort keys %vals) {

        next if ($v eq "COMMENT");

        #A header file include, print it later
        if ($v eq DTSI_INCLUDE) {
            $include = $vals{$v};
        }
        #A nested node
        elsif (ref($vals{$v}) eq "HASH") {
            printNode($f, $level+1, $v, %{$vals{$v}});
        }
        #An array of nested nodes
        elsif (ref($vals{$v}) eq "ARRAY") {
            my @array = @{$vals{$v}};
            &printNodes($f, $level+1, @array);
        }
        elsif ($vals{$v} ne STANDALONE_PROPERTY) {
            printProperty($f, $level+1, $v, $vals{$v});
        }
        else {
            printStandaloneProperty($f, $level+1, $v);
        }
    }

    #Now print the includes, if any.
    if ($include ne "") {
        my @incs = split(',', $include);
        foreach my $i (@incs) {
            print $f "#include \"$i\";\n";
        }
    }

    print $f indent($level) . "};\n";
}


#Prints a comma separated list of properties.
#e.g.  a = "b, c, d";
#  $f = file handle
#  $level = indent level (0,1,etc)
#  $name = name of property
#  @vals = list of property values
sub printPropertyList()
{
    my ($f, $level, $name, @vals) = @_;

    print $f indent($level) . "$name = ";

    for (my $i = 0;$i < scalar @vals; $i++) {
        print $f "\"$vals[$i]\"";
        if ($i < (scalar(@vals) - 1)) {
            print $f ", ";
        }
    }
    print $f ";\n"
}


#Prints a single property.  e.g. a = "b";
#  $f = file handle
#  $level = indent level (0,1,etc)
#  $name = name of property
#  @vals = property values
sub printProperty()
{
    my ($f, $level, $name, $val) = @_;
    my $quote = "\"";

    $val = convertAlias($val);

    #properties with < > or single word aliases don't need quotes
    if (($val =~ /<.*>/) || ($val =~ /^&\w+$/)) {
        $quote = "";
    }

    print $f indent($level) . "$name = $quote$val$quote;\n";
}


#Prints a standalone property e.g. some-property;
#  $f = file handle
#  $level = indent level (0,1,etc)
#  $name = name of property
sub printStandaloneProperty()
{
    my ($f, $level, $name) = @_;
    print $f indent($level) . "$name;\n";
}


#Replace '(alias)' with '&'.
#Needed because Serverwiz doesn't properly escape '&'s in the XML,
#so the '(alias)' string is used to represent the alias
#specifier instead of '&'.
sub convertAlias() {
    my $val = shift;
    $val =~ s/\(alias\)/&/g;
    return $val
}


#Returns the target for the BMC chip.
#Not worrying about multiple BMC systems for now.
sub getBMCTarget()
{
    foreach my $target (sort keys %{ $g_targetObj->getAllTargets() })
    {
        if ($g_targetObj->getType($target) eq "BMC") {
           return $target;
        }
    }
    return "";
}


#Prints the device tree version line.
#  $f = file handle
sub printVersion()
{
    my $f = shift;
    print $f VERSION."\n"
}


#Prints the #include line for pulling in an include file.
#  $f = file handle
#  $level = indent level (0,1,etc)
sub printIncludes()
{
    my ($f, $level) = @_;
    my @includes = getIncludes($g_bmc);

    foreach my $i (@includes) {
        #if a .dtsi, gets " ", otherwise < >
        if ($i =~ /\.dtsi$/) {
            $i = "\"" . $i . "\"";
        }
        else {
            $i = "<" . $i . ">";
        }
        print $f indent($level) . "#include $i;\n";
    }
}


#Returns an array of includes from the BMC_DT_INCLUDES attribute
#on the target passed in.
#  $target = the target to get the includes from
sub getIncludes()
{
    my $target = shift;
    my @includes;

    if (!$g_targetObj->isBadAttribute($target, "BMC_DT_INCLUDES")) {
        my $attr = $g_targetObj->getAttribute($target, "BMC_DT_INCLUDES");
        $attr =~ s/\s+//g; #remove whitespace
        $attr =~ s/NA,*//g; #remove the NAs
        my @incs = split(',', $attr);

        foreach my $i (@incs) {
            push @includes, $i
        }
    }

    return @includes;
}


#Prints the root node starting bracket.
#  $f = file handle
sub printRootNodeStart() {
    my $f = shift;
    print $f "\\ \{\n";
}


#Prints the root node ending bracket.
#  $f = file handle
#  $level = indent level (0,1,etc)
sub printRootNodeEnd() {
    my ($f, $level) = @_;
    print $f indent($level)."\};\n";
}


#Returns a string that can be used to indent based on the
#level passed in.  Each level is an additional 4 spaces.
#  $level = indent level (0,1,etc)
sub indent() {
    my $level = shift;
    return ' ' x ($level * 4);
}


#Will look for all the connections of the specified type coming from
#any sub target of the specified target, instead of just 1 level down
#like the Targets inteface does.  Needed because sometimes we have
#target->pingroup->sourceunit instead of just target->sourceunit
#  $target = the target to find connections off of
#  $bus = the bus type
#  $partType = destination part type, leave off if a don't care
sub findConnections() {
    my ($target, $bus, $partType) = @_;
    my %allConnections;
    my $i = 0;

    #get the ones from target->child
    my $connections = $g_targetObj->findConnections($target, $bus, $partType);
    if ($connections ne "") {
        foreach my $c (@{$connections->{CONN}}) {
            $allConnections{CONN}[$i] = { %{$c} };
            $i++;
        }
    }

    #get everything deeper
    my @children = getAllTargetChildren($target);
    foreach my $c (@children) {
        my $connections = $g_targetObj->findConnections($c, $bus, $partType);
        if ($connections ne "") {

            foreach my $c (@{$connections->{CONN}}) {
                $allConnections{CONN}[$i] = { %{$c} };
                $i++;
            }
        }
    }

    #Match the Targets::findConnections return strategy
    if (!keys %allConnections) {
        return "";
    }

    return \%allConnections;
}

#Returns every sub target, not just the 1st level children.
#  $target = the target to find the children of
sub getAllTargetChildren()
{
    my $target = shift;
    my @children;

    my $targets = $g_targetObj->getTargetChildren($target);
    if ($targets ne "") {

        foreach my $t (@$targets) {
            push @children, $t;
            my @more = getAllTargetChildren($t);
            push @children, @more;
        }
    }

    return @children;
}


sub printUsage
{
    print "gen_devtree.pl -x [XML filename] -o [output filename]\n";
    exit(1);
}