Subversion Repositories openfire_core

#!/usr/bin/perl

##############################################################################

# create_array.pl

# 

# Creates EDK input files needed to create an array of OpenFire processors.

#

# Stephen Douglas Craven

# modified 11/18/2005

# Virginia Tech

#

# WARNING!  This script may break with newer / older versions of the EDK.

# Works with 7.1.

#

##############################################################################

# Globals

use vars qw/ %opt /;

# Command line options processing

sub init()

{

    use Getopt::Std;

    my $opt_string = 'hn:m:p:';

    getopts( "$opt_string", \%opt ) or usage();

    usage() if ($opt{h} or !$opt{n} or ($opt{n} < 1));

}

# Message about this program and how to use it

sub usage()

{

    print STDERR << "EOF";

This program modifies an EDK MHS file instantiating and connecting

the specified number of OpenFires in an array controlled by the MicroBlaze

master.  Currently only unidirectional ring networks are supported.

Also modifies a MSS file for the master MB.

usage: $0 [-h] -n # <-d> <-o filename>

 -h                  : this (help) message

 -n #                : positive number of processors in the array (not counting master node)

 -m MB_instance_name : instance name of master MicroBlaze (default = microblaze_0)

 -p project_name     : name of project (default = system)

example: $0 -n 16 -m microblaze_0 -p system

EOF

exit(0);

}

#############################################

# Begin MHS file component declarations

#    This script works by adding FSL links

#    and OpenFires to existing MHS / MSS

#    files.

#############################################

$fsl_bus1 = "BEGIN fsl_v20

 PARAMETER INSTANCE = ";

$fsl_bus2 =" PARAMETER HW_VER = 2.00.a

 PARAMETER C_EXT_RESET_HIGH = 0

 PARAMETER C_FSL_DEPTH = 1

 PORT FSL_Clk = sys_clk_s

 PORT SYS_Rst = sys_rst_s

END

";

$openfire_instance1 = "BEGIN openfire_top_syn

 PARAMETER INSTANCE = ";

$openfire_instance2 = " BUS_INTERFACE SFSL = ";

$openfire_instance3 = " BUS_INTERFACE MFSL = ";

$openfire_instance4 = " PORT clock = sys_clk_s

 PORT reset = sys_rst_s

END

";

# Begin MSS file declarations

$mss_openfire = "

BEGIN DRIVER

 PARAMETER DRIVER_NAME = generic

 PARAMETER DRIVER_VER = 1.00.a

 PARAMETER HW_INSTANCE = openfire";

init();

# setup MHS filehandler

if($opt{p}) {

        $outputfile = $opt{p}.".mhs";

} else {

        $outputfile = "system.mhs";

}

# setup master MB name

if($opt{m}) {

        $master_mb = $opt{m};

} else {

        $master_mb = "microblaze_0";

}

# Open MHS file for appending first... write OpenFires and FSLs to end of file

open(mhs_file, ">>$outputfile") || die("Could not open file $outputfile!");

# Create Backup of file before we modify it

system("cp $outputfile create_array_bck.mhs");

# Add master Nodes's FSL buses

print mhs_file $fsl_bus1."fsl_MB_slave\n";

print mhs_file $fsl_bus2."\n";

print mhs_file $fsl_bus1."fsl_MB_master\n";

print mhs_file $fsl_bus2."\n";

# Loop over the processors

for($i = 0; $i < $opt{n}; $i++)

{

        $node_num = "openfire".$i;

        $node_num_prev = "openfire".($i-1);

        $fsl_master = "fsl_".$node_num."_master\n";

        $fsl_slave = "fsl_".$node_num_prev."_master\n";

        # Add each processor to the MHS

        print mhs_file $openfire_instance1.$node_num."\n";

        # Depending on the location of the processor in the ring network,

        #     connect its FSL links to different interfaces (OpenFire or MicroBlaze)

        # Both FSLs connect to Master

        if($opt{n} == 1) {

                print mhs_file $openfire_instance2."fsl_MB_master\n";

                print mhs_file $openfire_instance3."fsl_MB_slave\n";

                print mhs_file $openfire_instance4."\n";

        # No FSLs connect to master

        } elsif(($i != 0) & ($i != ($opt{n}-1))) {

                print mhs_file $openfire_instance2.$fsl_slave;

                print mhs_file $openfire_instance3.$fsl_master;

                print mhs_file $openfire_instance4."\n";

                print mhs_file $fsl_bus1.$fsl_master;

                print mhs_file $fsl_bus2."\n";

        # Slave FSL connects to Master

        } elsif($i == 0) {

                print mhs_file $openfire_instance2."fsl_MB_master\n";

                print mhs_file $openfire_instance3.$fsl_master;

                print mhs_file $openfire_instance4."\n";

                print mhs_file $fsl_bus1.$fsl_master;

                print mhs_file $fsl_bus2."\n";

        # Master FSL connects to Master

        } else {

                print mhs_file $openfire_instance2.$fsl_slave;

                print mhs_file $openfire_instance3."fsl_MB_slave\n";

                print mhs_file $openfire_instance4."\n";

        }

}

close(mhs_file);

# Must add FSL interfaces to master MB

# Open file again for reading

open(mhs_file, $outputfile) || die("Could not open file $outputfile!");

# hopefully read in entire file

@lines=<mhs_file>;

# go ahead and close the file

close(mhs_file);

$master_fsl_parameters = " PARAMETER C_FSL_LINKS = 1

 BUS_INTERFACE SFSL0 = fsl_MB_slave

 BUS_INTERFACE MFSL0 = fsl_MB_master

 ";

# search for master MB to add FSL interfaces to it

# This could be improved

$master_found = 0;

$complete = 0;

$output = "";

foreach $line (@lines)

{

        $_ = $line;

        if(/$master_mb/)

        {

                $master_found = 1;

                $output = $output.$line;

        } elsif($master_found & /BUS_INTERFACE/)

        {

                $output = $output.$master_fsl_parameters.$line;

                $master_found = 0;

                $complete = 1;

        }else{

                $output = $output.$line;

        }

}

if(!$complete)

{

        die("Could not find the $master_mb instance!");

}

# Open file again for overwriting

open(mhs_file, ">$outputfile") || die("Could not open file $outputfile!");

# We overwrite the entire file with our modified system that includes FSL interfaces for the MB

print mhs_file $output;

close(mhs_file);

# find output MSS file

if($opt{p}) {

        $outputfile = $opt{p}.".mss";

} else {

        $outputfile = "system.mss";

}

# Create backup

system("cp $outputfile create_array_bck.mss");

# write OpenFire drivers to MSS file

open(mss_file, ">>$outputfile") || die("Could not open file $outputfile!");

print mss_file $mss_header;

for($i = 0; $i < $opt{n}; $i++)

{

        print mss_file $mss_openfire.$i."\n END\n";

}

close(mss_file);

exit;