Subversion Repositories soc_maker

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

#

#  File:      core_inst.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 core instantiation within

#     a SOC. It contains a params (parameters) hash,

#     which defines, which parameters are set to which values.

#     The type field is used to identify the SOCMaker::CoreDef

#     and the field @defn is initialized as reference to

#     the corresponding CoreDef instance.

#

#

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

module SOCMaker

class CoreInst

  include ERR

  attr_accessor :defn

  attr_accessor :type

  attr_accessor :params

  def initialize(  type, params = {} )

    init_with(  'type'   => type,

                'params' => params  )

    verify

  end

  def encode_with( coder )

    %w[ type params ].

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

  end

  def init_with( coder )

    serr_if( coder[ 'type' ] == nil,

      "no type is provided for a core instance",

      field: "type" )

    @type = coder[ 'type' ]

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

    serr_if( !@params.is_a?( Hash ), 'Parameters are not given as hash',

      field: 'params' )

  end

  def ports

    @ports.each_with_index do |(name, port_def), i|

      yield( name.to_s, port_def[ :len ], port_def[ :dir ], i==@ports.size-1 )

    end

  end

  def generics

    @defn.generics do |name, type, default_value, is_last|

      value = @params[ name.to_sym ];

      value = value

      value = default_value if value == nil

      yield( name.to_s, type, value, is_last )

    end

  end

  def get_len( ifc_name, port_spec_name, inst = nil )

    if inst == nil

      tmp = @defn.interfaces[ ifc_name.to_sym ].

          ports.select{ |key,hash| hash.defn == port_spec_name.to_s }.

          keys.first.to_s

      return tmp.size == 0 ? 0 : @ports[ tmp.to_sym ][ :len ]

    else

      if inst == @name

        return get_len( ifc_name, port_spec_name )

      else

        return @defn.get_len( ifc_name, port_spec_name, inst )

      end

    end

  end

  def implements_port?( ifc_name, port_spec_name )

    @defn.implements_port?( ifc_name, port_spec_name )

  end

  def get_port( ifc_name, port_spec_name )

    tmp = @defn.interfaces[ ifc_name.to_sym ].

        ports.select{ |key,hash| hash.defn == port_spec_name.to_s }.

        keys.first.to_s

    return [ tmp, @ports[ tmp.to_sym ] ]

  end

  def verify

    @defn = SOCMaker::lib.get_core( @type )

    # check, if the instance parameters in the core definition

    @params.each do |param_name, value|

      verr_if(  @defn.inst_parameters[ param_name ] == nil,

                "Parameter not found: " + param_name.to_s,

        field: 'params' )

    end

    ## auto-complete parameters with default values

    @defn.inst_parameters.each do |param_name, param|

      # auto-complete to default values

      @params[ param_name ] ||= param.default

    end

#   @_params ||= {}

#   if @params != nil

#     @params.each do |name, val|

#

#       param_type = defn.inst_parameters[ name ].type

#

#       if val.is_a? String

#         eval_match = SOCMaker::conf[ :eval_regex ].match( val )

#         #TODO error handling

#         if eval_match

#           #eval_func = eval_match.captures[0]

#           @_params[ name ] = { value: eval( eval_str ).to_s, type: param_type }

#         else

#           @_params[ name ] = { value: val, type: param_type }

#         end

#       else

#         @_params[ name ] = { value: val, type: param_type }

#       end

#     end

#   end

    @ports ||= {}

    @defn.ports do |port_name, port_dir, port_len, is_last |

      if port_len.is_a?( String )

        param_match = SOCMaker::conf[ :length_regex ].match( port_len )

        if param_match and @params[ port_len.to_sym ] != nil

          tmp =@params[ port_len.to_sym ]

          tmp = tmp.to_i if tmp.is_a?( String )

          @ports[ port_name.to_sym ] = { len: tmp, dir: port_dir }

        else

          SOCMaker::logger.error( "Failed to evaluate #{port_len} for port #{port_name}" )

        end

      else

        @ports[ port_name.to_sym ] = { len: port_len, dir: port_dir }

      end

    end

    lerr_if( @defn == nil, 'Core not found in lib',

      field:    'cores'    )

  end

  def get_core_def( inst )

      tmp = @defn.get_core_def( inst )

      if tmp != nil

        return tmp

      elsif inst == @name

        return self

      else

        return nil

      end

  end

  def gen_toplevel( coder = VHDLCoder.new() )

    #

    # create filename

    #

    file_name = @defn.name.dup

    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 + "'" )

    SOCMaker::logger.proc( "verifying first ..." )

    # TODO: this is a fix, that the parameters in core_inst.ports are updated.

    #       A good approach for verifying, which checks the whole consistency, needs

    #       to be done

    @defn.cores.each do |inst_name, inst|

      inst.verify

    end

    #

    # 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

    #

    @defn.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

    @defn.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

    #

    @defn.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(

      get_core_def( src.keys.first.to_s ).interfaces[ src.values.first ].name,

      get_core_def( src.keys.first.to_s ).interfaces[ src.values.first ].version )

    #port_used   = {};

    length_tmp  = {};

    ifc_spec.ports.keys.each do |_name|

      # TODO: bis dahin konnte angenommen werden, dass self auch eine Art instanz ist,

      #       aber hier geht das nicht mehr, weil get_len nur für CoreInst definiert ist.

      #

      # create a length table

     #port_used[ _name ] = false

     #dst.each do |inst_name, ifc_name|

     #  port_used[ _name ] ||= get_core_def( inst_name ).implements_port?( ifc_name, _name )

     #end

     #src.each do |inst_name, ifc_name|

     #  port_used[ _name ] ||= get_core_def( inst_name ).implements_port?( ifc_name, _name )

     #end

      length_tmp[ _name ] = []

      dst.each do |inst_name, ifc_name|

        length_tmp[ _name ] << get_len( ifc_name, _name, inst_name )

      end

      src.each do |inst_name, ifc_name|

        length_tmp[ _name ] << get_len( ifc_name, _name, inst_name )

      end

    end

    # getting the maximum length for each signal

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

    p max_length

    coder.ifc_declaration( ifc_spec, name, max_length )

    src.keys.each do |inst_name|

      src_inst[ inst_name ]            = @defn.cores[ inst_name ]

    end

    dst.keys.each do |inst_name|

      dst_inst[ inst_name ]            = @defn.cores[ inst_name ]

    end

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

  end

  def to_s

    "type:     #{type}\n"   +

    "params:   #{params}\n"

  end

  def ==(o)

    o.class     == self.class   &&

    o.type      == self.type    &&

    o.params    == self.params

  end

end # CoreInst

end # SOCMaker

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