Subversion Repositories soc_maker

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

#

#  File:      soc_def.rb

#

#  Author:    Christian Hättich

#

#  Project:   System-On-Chip Maker

#

#  Target:    Linux / Windows / Mac

#

#  Language:  ruby

#

#

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

#

#

#   Copyright (C) 2014  Christian Hättich  - feddischson [ at ] opencores.org

#

#   This program is free software: you can redistribute it and/or modify

#   it under the terms of the GNU General Public License as published by

#   the Free Software Foundation, either version 3 of the License, or

#   (at your option) any later version.

#

#   This program is distributed in the hope that it will be useful,

#   but WITHOUT ANY WARRANTY; without even the implied warranty of

#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#   GNU General Public License for more details.

#

#   You should have received a copy of the GNU General Public License

#   along with this program.  If not, see .

#

#

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

#

#   Description:

#     This class represents a System-on-chip and derives

#     the functionallity from Component.

#     The two important fields are

#       - @cores: holds all core-instances

#       - cons:   holds all connections

#     In addition, the field @static is used to store

#     static parameters, which are set for cores used in this SOC.

#

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

module SOCMaker

class SOCDef < Component

  include ERR

  include YAML_EXT

  attr_accessor :cores

  attr_accessor :cons

  attr_accessor :static

  def initialize( name, version, toplevel, options = {} )

    init_with( { 'name'     => name,

                 'version'  => version,

                 'toplevel' => toplevel }.merge( options ) )

  end

  def encode_with( coder )

    super coder

    %w[ cores cons static ].

      each { |v| coder[ v ] = instance_variable_get "@#{v}" }

  end

  def init_with( coder )

    super coder

    @cores  = coder[ 'cores'  ] || {}

    @static = coder[ 'static' ] || {}

    @cons   = coder[ 'cons'   ] || {}

  end

  def verify

    super( true )

    @cores.each do |core_name, core_inst|

      core_inst.verify

    end

  end

  def get_and_ensure_dst_dir!( core_name )

      dst_dir =  File.expand_path(

            File.join(

              SOCMaker::conf[ :build_dir ],

              SOCMaker::conf[ :hdl_dir   ],

              core_name ) )

      FileUtils.mkdir_p dst_dir

      return dst_dir

  end

  # SOCMaker::logger.error( "instantiation #{inst_name} is already in use" )

  def inst_in_use?( inst_name )

       @cores[ inst_name.to_sym ] != nil or

       @cons[ inst_name.to_sym ]  != nil

  end

  def rm( inst_name )

    if @cores[ inst_name.to_sym ] != nil

      # TODO: remove also all related connections

      @cores.delete( inst_name.to_sym )

    elsif @cons[ inst_name.to_sym ]  != nil

      @cons.delete( inst_name.to_sym )

    else

      return false

    end

    return true

  end

  def add_core( name, version, inst_name )

    return false if inst_in_use?( inst_name )

    # check, if the core exits in our library

    #  if not: an error will be raised

    SOCMaker::lib.get_core( name, version )

    @cores[ inst_name.to_sym ] = SOCMaker::CoreInst.new( name+version )

  end

  def ifc_in_use?( inst_name, ifc_name )

    # go through all connections and check,

    # that non of the interfaces we want to connect is used

    @cons.each do |_con_name, con_def|

      return true if con_def[ :mapping ][ 0 ][ inst_name.to_sym] == ifc_name.to_sym

      return true if con_def[ :mapping ][ 1 ][ inst_name.to_sym] == ifc_name.to_sym

    end

    return false

  end

  def add_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )

    return nil if inst_in_use?( con_name )

   [ [ inst1, ifc1_name ],

     [ inst2, ifc2_name ] ].each do |sub_arr|

      perr_if( ifc_in_use?( sub_arr[ 0 ], sub_arr[ 1 ] ),

          "Interface #{sub_arr[ 1 ]} of instance '#{sub_arr[ 0 ]}' is already in use " )

    end

    [ inst1, inst2 ].each do |inst|

      perr_if( @cores[ inst.to_sym ] == nil,

          "Instance '#{inst}' does not exist in SOC '#{self.name}'" )

    end

    # get the core-specs

    core_spec_1 = SOCMaker::lib.get_core( @cores[ inst1.to_sym ].type )

    core_spec_2 = SOCMaker::lib.get_core( @cores[ inst2.to_sym ].type )

    [ [ core_spec_1, ifc1_name ],

      [ core_spec_2, ifc2_name ] ].each do |sub_arr|

        perr_if( sub_arr[ 0 ].interfaces[ sub_arr[ 1 ].to_sym ] == nil,

          "Interface '#{sub_arr[ 1 ]}' dosn't exist in core '#{sub_arr[0].name}' " )

    end

    # check name and version of the ifcs which will be connected

    perr_if( core_spec_1.interfaces[ ifc1_name.to_sym ].name     !=

             core_spec_2.interfaces[ ifc2_name.to_sym ].name     ||

             core_spec_1.interfaces[ ifc1_name.to_sym ].version  !=

             core_spec_2.interfaces[ ifc2_name.to_sym ].version,

          "Can't connect #{

            core_spec_1.interfaces[ ifc1_name.to_sym ].name } - #{

            core_spec_2.interfaces[ ifc2_name.to_sym ].name } : #{

            core_spec_1.interfaces[ ifc1_name.to_sym ].version } - #{

            core_spec_2.interfaces[ ifc2_name.to_sym ].version }" )

    @cons[ con_name.to_sym ] = {

          :rule    => "or",

          :mapping => [ { inst1.to_sym => ifc1_name.to_sym },

                        { inst2.to_sym => ifc2_name.to_sym } ] }

  end

  def set_param( instance, param, value )

    # get instance

    core_inst = @cores[ instance.to_sym ]

    perr_if( core_inst == nil,

      "Can't find '#{instance}' in SOC" )

    # get the core-definition

    core_def = SOCMaker::lib.get_core( core_inst.type  )

    # check if parameter exist

    if core_def.inst_parameters[ param.to_sym ] != nil

      core_inst.params[ param.to_sym ] = value

    else

      perr_if( true,

        "Parameter '#{param}' not found in '#{core_def.name}'" )

    end

  end

  def get_param( instance, param )

    # get instance

    core_inst = @cores[ instance.to_sym ]

    perr_if( core_inst == nil,

      "Can't find '#{instance}' in SOC" )

    param_val = core_inst.params[ param.to_sym ]

    perr_if( param_val == nil,

      "Can't find parameter '#{param}' in '#{instance}'" )

    return param_val

  end

  def set_sparam( core, param, value )

    #get instance

    # check, if we are instantiating this core

    perr_if( @cores.select{ |name,inst| inst.type == core }.size == 0,

      "Core '#{core}' is not instantiated in this SOC" )

    # get the core-definition

    core_def = SOCMaker::lib.get_core( core )

    # check if parameter exist

    perr_if( core_def.static_parameters.select{ |f,p| p.parameters[ param.to_sym ] != nil }.size == 0,

        "Parameter '#{param}' not found in '#{core_def.name}'" )

    @static[ core.to_sym ] ||= {}

    @static[ core.to_sym ][ param.to_sym ] = value

  end

  def get_sparam( core, param )

    perr_if( @static[ core.to_sym ] == nil,

      "Core '#{core}' does not exist in this SOC" )

    perr_if( @static[ core.to_sym ][ param.to_sym ] == nil,

      "Parameter '#{param}' does not exist for core '#{core}'" )

    return @static[ core.to_sym ][ param.to_sym ]

  end

  def gen_toplevel( coder = VHDLCoder.new() )

    file_name = @name

    if coder.is_a?( VHDLCoder )

      file_name << ".vhd"

    elsif coder.is_a?( VerilogCoder )

      file_name << ".v"

    else

      perr_if( true,

        "No valid coder" )

    end

    SOCMaker::logger.proc( "START of creating top-level '" + file_name + "'" )

    #

    # Create a unique list of cores and

    # add every core to your implementation.

    # Even if there are multiple instances of a core,

    # we need to decalre it only once

    #

    @cores.values.uniq{|x| x.type }.each do |inst; spec|

      spec = SOCMaker::lib.get_core( inst.type  )

      SOCMaker::lib.check_nil( spec, "Can't find #{ inst.type } in SOC library" )

      coder.add_core_declaration( inst.type, spec )

    end

   #core_instances = {}

   #@cores.each do |inst_name, _core_inst|

   #  # the corresponding core from SOC lib

   #  core_def = SOCMaker::lib.get_core( _core_inst[ :type ] )

   #  core_instances[ inst_name ] = SOCMaker::CoreInst.new( core_def, _core_inst[ :params ] )

   #end

    @cores.each do |inst_name, inst|

      coder.add_core_inst( inst_name.to_s, inst )

    end

    # Iterate over all connections:

    #  - create signal instances

    #  - add assignments

    #

    @cons.each do |con_name, con_def|

      gen_toplevel_con(   con_name.to_s,

                          con_def[ :rule ],

                          con_def[ :mapping ][0],

                          con_def[ :mapping ][1],

      coder  )

    end

    SOCMaker::logger.proc( "writing top-level" )

    file_dir  = File.join( SOCMaker::conf[ :build_dir ],

                           SOCMaker::conf[ :hdl_dir   ] )

    ::FileUtils.mkdir_p file_dir

    file_path = File.join( file_dir, file_name )

    File.open( file_path, 'w' ) do |f|

      f.write( coder.get_entity( self, "test" ) )

    end

    SOCMaker::logger.proc( "END of creating top-level" )

  end

  def gen_toplevel_con( name, rule, src, dst, coder )

    src_inst            = {};

    dst_inst            = {};

    # fetch somehow the spec

    ifc_spec = SOCMaker::lib.get_ifc(

      @cores[ src.keys.first ].defn.interfaces[ src.values.first ].name,

      @cores[ src.keys.first ].defn.interfaces[ src.values.first ].version )

    length_tmp = {};

    ifc_spec.ports.keys.each do |_name|

      # create a length table

      length_tmp[ _name ] = []

      dst.each do |inst_name, ifc_name|

        length_tmp[ _name ] << @cores[ inst_name ].get_len( ifc_name, _name )

      end

      src.each do |inst_name, ifc_name|

        length_tmp[ _name ] << @cores[ inst_name ].get_len( ifc_name, _name )

      end

    end

    # getting the maximum length for each signal

    max_length = Hash[ length_tmp.map{ |key, arr| [ key, arr.max ] } ]

    coder.ifc_declaration( ifc_spec, name, max_length )

    src.keys.each do |inst_name|

      src_inst[ inst_name ]            = @cores[ inst_name ]

    end

    dst.keys.each do |inst_name|

      dst_inst[ inst_name ]            = @cores[ inst_name ]

    end

    coder.ifc_assignment( ifc_spec, name, max_length, src_inst, dst_inst, src, dst )

  end

  def copy_files

    SOCMaker::logger.proc( "START of copying all HDL files" )

    #

    # Create a unique list of cores and

    # for every core, create a directory and copy files

    #

    @cores.values.uniq{|x| x.type }.each do |core_inst; core_def, dst_dir|

      core_def = SOCMaker::lib.get_core( core_inst.type )

      # create destination directory name and ensure, that it is exist

      dst_dir  = get_and_ensure_dst_dir!( core_def.name )

      # copy each file into destination dir

      core_def.hdlfiles.each do |file, val|

        file_path = File.join( core_def.dir, val.path )

        dst_path = File.join( dst_dir, file.to_s )

        SOCMaker::logger.proc( "copy #{file_path} to #{ dst_path} " )

        FileUtils.cp( file_path, dst_path )

      end

      #

      # handle the static parameters

      #   (search and replace in pakckage/include files)

      core_def.static_parameters.each do |file, param|

        token_val_map = {}

        param.parameters.each do |n,p|

          if  @static[ core_inst.type.to_sym ]      != nil and

              @static[ core_inst.type.to_sym ][ n ] != nil

            # use value defined in soc-spec

            token_val_map[ p.token ] = @static[ core_inst.type.to_sym ][ n ]

          else

            # use default value from core-spec

            token_val_map[ p.token ] =  p.default

          end

        end

        # create file paths

        src_path = File.join( core_def.dir, param.path )

        dst_dir  = get_and_ensure_dst_dir!( core_def.name )

        dst_path = File.join( dst_dir, param.file_dst )

        # process each line of input file

        # and replace tokens by value via

        # regular expression

        File.open( dst_path, 'w' ) do |dst_f|

          File.open( src_path ) do |src_f|

            SOCMaker::logger.proc( "create #{dst_path} from #{ src_path} " )

            while line = src_f.gets

              token_val_map.each { |token, val| line = line.sub( Regexp.new( token.to_s ), val.to_s ) }

              dst_f.puts line

            end

          end

        end

      end

    end

    SOCMaker::logger.proc( "END of copying all HDL files" )

  end

  def ==(o)

    o.class   == self.class   &&

    o.cores   == self.cores   &&

    o.cons    == self.cons    &&

    o.static  == self.static  &&

    super( o )

  end

end # class SOCSpec

end # module SOCMaker

# vim: noai:ts=2:sw=2