OpenCores
URL https://opencores.org/ocsvn/soc_maker/soc_maker/trunk

Subversion Repositories soc_maker

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 10 to Rev 9
    ↔ Reverse comparison
  •

Rev 10 → Rev 9

/soc_maker/trunk/lib/soc_maker/hdl_coder.rb
199,16 → 199,16
end
 
def add_ifc_default_assignment( inst, inst_name, ifc_name )
def add_ifc_default_assignment( inst, inst_name, ifc_name, default )
 
 
tmp = ""
inst.ports( ifc_name.to_s ) do |port_name, dir, length, default_val, is_last|
inst.ports( ifc_name.to_s ) do |port_name, dir, length, default, is_last|
if dir == 1 # assign default value only if it is an input
if length > 1
tmp << "#{inst_name}_#{port_name} <= ( others => '#{default_val}' );\n"
tmp << "#{inst_name}_#{port_name} <= ( others => '#{default}' );\n"
else
tmp << "#{inst_name}_#{port_name} <= '#{default_val}';\n"
tmp << "#{inst_name}_#{port_name} <= '#{default}';\n"
end
end
end
275,6 → 275,7
tmp << "#{inst_name}_#{tmp_name}"
tmp << " and \n" unless i == src_inst_sel.size-1
else
puts "#{port_tmp_name}: #{length[port_name] > 1}"
if length[ port_name ] > 1
tmp << "( others => '0' )"
else
/soc_maker/trunk/lib/soc_maker/conf.rb
155,7 → 155,6
 
#
# Regular expression to match a component's name (core-name or SOC-name)
# (Obsolete)
#
:name_regex => /^[a-zA-Z]+[a-zA-Z0-9_\-]*$/,
 
/soc_maker/trunk/lib/soc_maker/core_inst.rb
52,13 → 52,6
attr_accessor :type
attr_accessor :params
 
#
# Constructor
# There is one mandatory attributes and an optional one.
#
# *type*:: The id of the core-definition, which is instanciated
# *params*:: Instanciation parameters
#
def initialize( type, params = {} )
init_with( 'type' => type,
'params' => params )
168,7 → 161,7
#
# Get filename
#
file_name = coder.filename( @defn.dir_name )
file_name = coder.filename( @defn.name )
 
SOCMaker::logger.proc( "START of creating top-level '" + file_name + "'" )
 
195,6 → 188,7
end
 
 
# Iterate over all connections:
# - create signal instances
# - add assignments
218,7 → 212,7
SOCMaker::conf[ :hdl_dir ] )
::FileUtils.mkdir_p file_dir
File.open( File.join( file_dir, file_name ), 'w' ) do |f|
f.write( coder.get_hdl_code( self, @defn.toplevel ) )
f.write( coder.get_hdl_code( self, @defn.name ) )
end
SOCMaker::logger.proc( "END of creating top-level hdl code for #{@defn.name}" )
 
248,7 → 242,7
ifc_sel = @_ifcs_evaluated.select{ |k,v| args.include?( k.to_s ) }
end
 
ifc_sel.values.each_with_index do |ifc, i_ifc|
ifc_sel.each_with_index do |(ifc_name, ifc), i_ifc|
ifc.each_with_index do |(port_name, port_def), i_port|
yield( port_name.to_s,
port_def[ :dir ],
314,7 → 308,7
keys.first.to_s
return tmp.size == 0 ? 0 : @_ifcs_evaluated[ ifc_name.to_sym ][ tmp.to_sym ][ :len ]
else
if inst == @defn.toplevel.to_sym
if inst == @defn.name.to_sym
return port_length( ifc_name, port_spec_name )
else
return @defn.port_length( ifc_name, port_spec_name, inst )
398,13 → 392,22
# Get the interface specification by using the 1st source entry
# and searching for the core-definition.
#
ifc_spec = SOCMaker::lib.get_ifc( ifc.name, ifc.version )
 
if !@defn.ifc_in_use?( inst_name, ifc_name )
coder.add_ifc_default_assignment( inst, inst_name, ifc_name )
 
default_tmp = {};
ifc_spec.ports.each do |_name,_port|
default_tmp[ _name ] = _port[ :default ]
end
 
coder.add_ifc_default_assignment( inst, inst_name, ifc_name, default_tmp )
end
end
end
end
 
 
#
# This function is called during the toplevel generation
# for each connection.
425,7 → 428,8
# and searching for the core-definition.
#
ifc_spec = SOCMaker::lib.get_ifc(
core_definition( src.keys.first.to_s ).interfaces[ src.values.first ].id )
core_definition( src.keys.first.to_s ).interfaces[ src.values.first ].name,
core_definition( src.keys.first.to_s ).interfaces[ src.values.first ].version )
 
#
/soc_maker/trunk/lib/soc_maker/component.rb
61,8 → 61,8
# name of the core (mandatory)
attr_accessor :name
 
# ID of the core (mandatory)
attr_accessor :id
# version of the core (mandatory)
attr_accessor :version
# toplevel name (mandatory)
attr_accessor :toplevel
106,14 → 106,14
# can be given as a optinal hash
#
# *name*:: Name of this component
# *id*:: Id of this component
# *version*:: Version of this component
# *toplevel*:: Toplevel name of this component
# *optional*:: Non-mandatory values, which can be set during initialization.
#
#
def initialize( name, id, toplevel, optional = {} )
def initialize( name, version, toplevel, optional = {} )
init_with( { 'name' => name,
'id' => id,
'version' => version,
'toplevel' => toplevel }.merge( optional ) )
end
 
123,7 → 123,7
# +coder+:: An instance of the Psych::Coder to encode this class to a YAML file
#
def encode_with( coder )
%w[ name id description date license licensefile
%w[ name version description date license licensefile
author authormail vccmd toplevel interfaces
functions inst_parameters static_parameters ].
each { |v| coder[ v ] = instance_variable_get "@#{v}" }
147,18 → 147,24
serr_if( @name.size == 0,
'Name not defined (size == 0)',
field: 'name' )
verr_if( !!SOCMaker::conf[ :name_regex ].match( @name ) == false,
'The core name is invalid',
instance: @name,
field: 'name' )
serr_if( coder[ 'id' ] == nil,
'Id not defined',
serr_if( coder[ 'version' ] == nil,
'Version not defined',
instance: @name,
field: 'id' )
@id = coder[ 'id' ]
serr_if( @id.size == 0,
'Id not defined (size == 0)',
field: 'version' )
@version = coder[ 'version' ]
serr_if( @version.size == 0,
'Version not defined (size == 0)',
instance: @name,
field: 'id' )
field: 'version' )
 
verr_if( !@id.is_a?( String ),
# cast from numeric to string, if not given as string
@version = @version.to_s if @version.is_a? ( Numeric )
verr_if( !@version.is_a?( String ),
'The name must be of type string or numeric',
field: 'name' )
 
252,15 → 258,7
 
end
 
#
# the directory name of this core
#
def dir_name
@id.split(',').join("_")
end
 
 
 
#
# Runs a consistency check:
# Iterate over all interfaces and check, if the interface is
272,7 → 270,7
@interfaces.values.each_with_index do | ifc, i_ifc; ifc_def|
# get interface definition
ifc_def = SOCMaker::lib.get_ifc( ifc.id )
ifc_def = SOCMaker::lib.get_ifc( ifc.name, ifc.version )
 
 
# check, if all mandatory ports are implemented by this interface
356,7 → 354,7
@ifc_sel.values.each_with_index do | ifc, i_ifc; ifc_def|
# get interface definition
ifc_def = SOCMaker::lib.get_ifc( ifc.id )
ifc_def = SOCMaker::lib.get_ifc( ifc.name, ifc.version )
 
# loop over ports in this interface
ifc.ports.each_with_index do |(port_name, port_def), i_port |
366,7 → 364,7
perr_if( !ifc_def.ports.has_key?( defn_ref ),
"Can't find #{port_def} in" +
"interface definition #{ifc_def.name} " +
"id #{ifc_def.id}" )
"version #{ifc_def.version}" )
 
_port_name = port_name.to_s
_port_dir = ifc_def.ports[ defn_ref ][:dir] ^ ifc.dir
388,7 → 386,7
tmp = ( o.class == self.class )
return tmp if !tmp
 
%w[ name id description date license licensefile
%w[ name version description date license licensefile
author authormail vccmd toplevel interfaces
functions inst_parameters static_parameters ].
each do |v|
401,7 → 399,7
# Returns a string describing this instance
#
def to_s
"id: #{@id}\n" +
"version: #{@version}\n" +
"toplevel: #{@toplevel}\n" +
"description: #{@description}\n" +
"date: #{@date}\n" +
/soc_maker/trunk/lib/soc_maker/soc_def.rb
51,10 → 51,10
attr_accessor :cores
attr_accessor :cons
attr_accessor :static
def initialize( name, id, toplevel, optional = {} )
def initialize( name, version, toplevel, optional = {} )
init_with( { 'name' => name,
'id' => id,
'version' => version,
'toplevel' => toplevel }.merge( optional ) )
end
103,15 → 103,15
end
 
 
def add_core( id, inst_name )
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( id )
SOCMaker::lib.get_core( name, version )
@cores[ inst_name.to_sym ] = SOCMaker::CoreInst.new( id )
@cores[ inst_name.to_sym ] = SOCMaker::CoreInst.new( name+version )
end
 
 
139,7 → 139,7
def core_definition( inst )
if @cores[ inst.to_sym ] != nil
return @cores[ inst.to_sym ].defn
elsif inst == @toplevel
elsif inst == @name
return self
else
return nil
149,26 → 149,7
 
 
#def add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
def add_to_connection( *args )
 
if args.size == 4
inst1 = @toplevel
ifc1_name = args[ 0 ]
inst2 = args[ 1 ]
ifc2_name = args[ 2 ]
con_name = args[ 3 ]
elsif args.size == 5
inst1 = args[ 0 ]
ifc1_name = args[ 1 ]
inst2 = args[ 2 ]
ifc2_name = args[ 3 ]
con_name = args[ 4 ]
else
perr_if( true, "FATAL: wrong number of arguments (#{args.size}) for add_to_connection (3 or 4)" )
end
 
 
def add_to_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
perr_if( @cons[ con_name.to_sym ] == nil, "Connection instance #{con_name} not found" )
@cons[ con_name.to_sym ][:mapping][0][ inst1.to_sym ] = ifc1_name.to_sym
@cons[ con_name.to_sym ][:mapping][1][ inst2.to_sym ] = ifc2_name.to_sym
176,25 → 157,8
 
 
 
#def add_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
def add_connection( *args )
def add_connection( inst1, ifc1_name, inst2, ifc2_name, con_name )
 
if args.size == 4
inst1 = @toplevel
ifc1_name = args[ 0 ]
inst2 = args[ 1 ]
ifc2_name = args[ 2 ]
con_name = args[ 3 ]
elsif args.size == 5
inst1 = args[ 0 ]
ifc1_name = args[ 1 ]
inst2 = args[ 2 ]
ifc2_name = args[ 3 ]
con_name = args[ 4 ]
else
perr_if( true, "FATAL: wrong number of arguments (#{args.size}) for add_connection (3 or 4)" )
end
 
if @cores[ con_name.to_sym ] != nil
return nil
elsif @cons[ con_name.to_sym ] != nil
223,13 → 187,18
"The following interfaces do exist: '#{sub_arr[0].interfaces.keys}'" )
end
# check id of the ifcs which will be connected
perr_if( core_def_1.interfaces[ ifc1_name.to_sym ].id !=
core_def_2.interfaces[ ifc2_name.to_sym ].id,
# check name and version of the ifcs which will be connected
perr_if( core_def_1.interfaces[ ifc1_name.to_sym ].name !=
core_def_2.interfaces[ ifc2_name.to_sym ].name ||
core_def_1.interfaces[ ifc1_name.to_sym ].version !=
core_def_2.interfaces[ ifc2_name.to_sym ].version,
"Can't connect #{
core_def_1.interfaces[ ifc1_name.to_sym ].id} with #{
core_def_2.interfaces[ ifc2_name.to_sym ].id} " )
core_def_1.interfaces[ ifc1_name.to_sym ].name } - #{
core_def_2.interfaces[ ifc2_name.to_sym ].name } : #{
core_def_1.interfaces[ ifc1_name.to_sym ].version } - #{
core_def_2.interfaces[ ifc2_name.to_sym ].version }" )
@cons[ con_name.to_sym ] = {
:rule => "or",
:mapping => [ { inst1.to_sym => ifc1_name.to_sym },
314,7 → 283,7
core_def = SOCMaker::lib.get_core( core_inst.type )
 
# create destination directory name and ensure, that it is exist
dst_dir = Component.get_and_ensure_dst_dir!( core_def.dir_name )
dst_dir = Component.get_and_ensure_dst_dir!( core_def.name )
 
# copy each file into destination dir
core_def.hdlfiles.each do |file, val|
360,7 → 329,7
# create file paths
src_path = File.join( core_def.dir, sparam.path )
dst_dir = Component::get_and_ensure_dst_dir!( core_def.dir_name )
dst_dir = Component::get_and_ensure_dst_dir!( core_def.name )
dst_path = File.join( dst_dir, sparam.file_dst )
/soc_maker/trunk/lib/soc_maker/core_def.rb
35,6 → 35,13
# Description:
#
########
#
# TODO
#
#
###############################################################
 
 
module SOCMaker
 
 
57,41 → 64,16
attr_accessor :hdlfiles
 
 
#
# Constructor
# The four attributes are required, and all other attributes
# can be given as a optinal hash
#
# *name*:: Name of this component
# *id*:: Id of this component
# *hdl_files*:: Hash of HDL files
# *toplevel*:: Toplevel name
# *optional*:: Non-mandatory values, which can be set during initialization.
#
#
def initialize( name, id, hdl_files, toplevel, optional = {} )
def initialize( name, version, hdl_files, toplevel, optional = {} )
init_with( { 'name' => name,
'id' => id,
'version' => version,
'hdlfiles' => hdl_files,
'toplevel' => toplevel }.merge( optional ) )
end
 
#
# Encoder function (to yaml)
#
# +coder+:: An instance of the Psych::Coder to encode this class to a YAML file
#
def encode_with( coder )
super coder
coder[ 'hdlfiles' ] = @hdlfiles
end
 
#
# Initialization function (from yaml)
#
# +coder+:: An instance of the Psych::Coder to init this class from a YAML file
#
#
def init_with( coder )
super( coder )
 
115,15 → 97,8
 
 
 
#
# Loop over all generic values of the core
# and yield the block with the
# - generic name
# - generic type
# - the default value
# - is-last value
#
#
 
 
def generics
@inst_parameters.each_with_index do |(name, val), i|
yield( name.to_s, val.type, val.default, i == @inst_parameters.size-1 )
131,26 → 106,25
end
 
 
#
 
# this is a core_def and doesn't have
# sub-cores
def get_core_def( inst )
perr_if( nil, "We don't have sub-cores" )
return nil
end
 
 
#
# Nothing implemented, yet.
#
def consistency_check
super
end
 
 
#
# Equality operator
#
def param_ok?( param_name, param_value )
param = inst_parameters[ param_name.to_sym ]
param = static_parameters[ param_name.to_sym ] if param == nil
return false if param == nil
end
 
 
def ==(o)
o.class == self.class &&
o.hdlfiles == self.hdlfiles &&
157,14 → 131,7
super( o )
end
 
#
# Returns a string describing this instance
#
def to_s
super
end
 
 
end # class CoreDef
end # module SOCMaker
/soc_maker/trunk/lib/soc_maker/ifc_spc.rb
44,15 → 44,15
include YAML_EXT
 
attr_accessor :name
attr_accessor :id
attr_accessor :version
attr_accessor :ports
 
def initialize( name, id, optional = {} )
def initialize( name, version, optional = {} )
init_with( { 'name' => name,
'id' => id }.merge( optional ) )
'version' => version }.merge( optional ) )
end
def encode_with( coder )
%w[ name id ports ].
%w[ name version ports ].
each { |v| coder[ v ] = instance_variable_get "@#{v}" }
end
def init_with( coder )
69,15 → 69,15
field: "name" )
 
 
verr_if( coder[ 'id' ] == nil,
"Id is not defined",
field: "id" )
@id = coder[ 'id' ]
verr_if( !@id.is_a?( String ),
verr_if( coder[ 'version' ] == nil,
"Version is not defined",
field: "version" )
@version = coder[ 'version' ]
verr_if( !@version.is_a?( String ),
"Version is not defined as string",
instance: @name,
field: "id" )
verr_if( @id.size == 0,
field: "version" )
verr_if( @version.size == 0,
"Version has zero length",
field: "name" )
 
/soc_maker/trunk/lib/soc_maker/ifc_def.rb
39,17 → 39,16
# this information:
# The class represents an interface definition:
# - name of the interface (mandatory)
# - a id (mandatory)
# - a version (mandatory)
# - a direction (mandatry)
# - ports (hash of type SOCMaker::IfcPort, mandatory)
#
# Note: instances of this class are used withing core-definitions.
# Different cores may use the same interface, but with a
# different naming of the ports. For this reason, the name+id
# different naming of the ports. For this reason, the name+version
# is used to identify, which interface specification (SOCMaker::IfcSpc)
# is defined. The port-hash makes the relation between the core port-naming
# and the IfcSpc port-naming.
# TODO
#
###############################################################
58,17 → 57,17
include ERR
attr_accessor :name
attr_accessor :dir
attr_accessor :id
attr_accessor :version
attr_accessor :ports
 
def initialize( name, id, dir, ports )
def initialize( name, version, dir, ports )
init_with( 'name' => name,
'dir' => dir,
'id' => id,
'version' => version,
'ports' => ports )
end
def encode_with( coder )
%w[ name dir id ports ].
%w[ name dir version ports ].
each { |v| coder[ v ] = instance_variable_get "@#{v}" }
end
def init_with( coder )
86,17 → 85,18
"Name has zero length",
field: "name" )
 
# id
serr_if( coder[ 'id' ] == nil,
'id is not given for interface',
# version
serr_if( coder[ 'version' ] == nil,
'version is not given for interface',
instance: @name,
field: 'id' )
@id = coder[ 'id' ]
serr_if( !@id.is_a?( String ),
'Interface id is not defined as string',
field: 'version' )
@version = coder[ 'version' ]
@version = @version.to_s if @version.is_a?( Numeric )
serr_if( !@version.is_a?( String ),
'Interface version is not defined as string',
instance: @name,
field: 'id' )
verr_if( @id.size == 0,
field: 'version' )
verr_if( @version.size == 0,
"Version has zero length",
field: "name" )
 
144,7 → 144,7
o.class == self.class &&
o.name == self.name &&
o.dir == self.dir &&
o.id == self.id &&
o.version == self.version &&
o.ports == self.ports
end
 
/soc_maker/trunk/lib/soc_maker/lib.rb
53,9 → 53,16
# will store all cores
@cores_lib = {}
 
# will store the versions of all cores { name => { ver1, ver2, ver3 } }
@cores_ver = {}
 
# will store all interfaces
@ifc_lib = {}
 
# will store the versions of all interfaces { name => { ver1, ver2, ver3 } }
@ifc_ver = {}
 
 
# we remember paths, which we've already processed
@path_lut = []
 
64,7 → 71,9
 
def clear
@cores_lib.clear
@cores_ver.clear
@ifc_lib.clear
@ifc_ver.clear
@path_lut.clear
end
 
151,72 → 160,57
end
 
def add_core( core )
# generate key-string from name and vesion
core_key = core.name + core.version
 
# save core
@cores_lib[ core.id ] = core
@cores_lib[ core_key ] = core
@cores_ver[ core.name.to_sym ] = [] unless @cores_ver.has_key?(core.name.to_sym)
@cores_ver[ core.name.to_sym ] << core.version
SOCMaker::logger.info "loaded " +
core.name +
", id = " +
core.id
" version " +
core.version
end
 
def get_core( id )
tmp = @cores_lib[ id ]
check_nil( tmp, "Core with id '#{id}' does not exist" )
def get_core( name, version = "" )
core_key = name + version
tmp = @cores_lib[ core_key ]
check_nil( tmp, "Core '#{name}' version '#{version}' does not exist" )
return tmp
end
 
def rm_core( arg )
if arg.is_a?( String )
check_nil( @cores_lib[ arg ], "Core with id '#{arg}' does not exist" )
@cores_lib.delete( arg )
 
elsif arg.is_a?( SOCMaker::CoreDef )
check_nil( @cores_lib[ arg.id ], "Core with id '#{arg.id}' does not exist" )
@cores_lib.delete( arg.id )
 
else
raise SOCMaker::ERR::LibError.new( "", "FATAL: Can't remove interface" )
end
def rm_core( core )
core_key = core.name + core.version
@cores_lib.delete( core_key )
end
 
 
 
 
def add_ifc( ifc )
@ifc_lib[ ifc.id ] = ifc
ifc_key = ifc.name + ifc.version
@ifc_lib[ ifc_key ] = ifc
@ifc_ver[ ifc.name.to_sym ] = [] unless @ifc_ver.has_key?(ifc.name.to_sym)
@ifc_ver[ ifc.name.to_sym ] << ifc.version
end
 
def get_ifc( id )
tmp = @ifc_lib[ id ]
check_nil( tmp, "Interface with id '#{id}' does not exist" )
def get_ifc( name, version = "" )
ifc_key = name + version
tmp = @ifc_lib[ ifc_key ]
check_nil( tmp, "Interface '#{name}' version '#{version}' does not exist" )
return tmp
end
 
def rm_ifc( arg )
 
if arg.is_a?( String )
check_nil( @ifc_lib[ arg ],
"Interface with id '#{arg}' does not exist" )
@ifc_lib.delete( arg )
 
elsif arg.is_a?( SOCMaker::IfcSpc )
check_nil( @ifc_lib[ arg.id ],
"Interface with id '#{arg.id}' does not exist" )
@ifc_lib.delete( arg.id )
 
else
raise SOCMaker::ERR::LibError.new( "", "FATAL: Can't remove interface" )
end
 
def rm_ifc( ifc )
ifc_key = ifc.name + ifc.version
@ifc_lib.delete( ifc_key )
end
 
def to_s
"IP-Core - lib: \n" +
@cores_lib.keys.to_s +
"\n\nIP-Interfaces - lib: \n" +
@ifc_lib.keys.to_s
"\n\nIP-Core - versions: \n" +
@cores_ver.to_s +
"\n\nInterface - lib: \n" +
@ifc_lib.keys.to_s +
"\n\nInterface - versions: \n" +
@ifc_ver.to_s + "\n"
end
 
 
234,30 → 228,30
# get all interfaces in a list
#
# TODO untested: do we need this?
# def get_ifcs( core )
# ifc_list = [];
# core.interfaces.values.each do |ifc; ifc_tmp|
# ifc_tmp = get_ifc( ifc[ :name ], ifc[ :version ] )
#
# # error handling
# if ifc_tmp == nil
# SOCMaker::logger.error "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"
# raise NameError, "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"
# end
#
# # add interface to list
# ifc_list << ifc_tmp
# end
# return ifc_list
# end
def get_ifcs( core )
ifc_list = [];
core.interfaces.values.each do |ifc; ifc_tmp|
ifc_tmp = get_ifc( ifc[ :name ], ifc[ :version ] )
# error handling
if ifc_tmp == nil
SOCMaker::logger.error "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"
raise NameError, "Can't find #{ifc[ :name ]} version #{ifc[ :version ]} in SOC library"
end
 
# add interface to list
ifc_list << ifc_tmp
end
return ifc_list
end
 
 
#
# TODO add test code
#
def cores
@cores_lib.each do |id,core|
yield( id.to_s, core )
@cores_lib.each do |nameversion,core|
yield( nameversion.to_s, core )
end
end
/soc_maker/trunk/lib/soc_maker/cli.rb
96,9 → 96,9
# New
#
NEW_USAGE =
" > new <<name>> <<id>> <<toplevel>> # opens a system-on-chip file
" > new <<name>> <<version>> <<toplevel>> # opens a system-on-chip file
- <<name>> : the SOC name
- <<id>> : the SOC id
- <<version>> : the SOC version
- <<toplevel>> : the toplevel name
"
def do_new( args )
129,7 → 129,7
puts "loading #{args[0]}"
@soc = SOCMaker::from_f( args[0] )
SOCMaker::lib.add_core( @soc )
@soc_inst = SOCMaker::CoreInst.new( "#{@soc.version.to_s}" )
@soc_inst = SOCMaker::CoreInst.new( "#{@soc.name}#{@soc.version}" )
#puts FMSG if @soc.load_soc( args[ 0 ] ) == nil
end
end
152,17 → 152,18
# Add
#
ADD_USAGE =
" > add <<id>> <<name>>
# adds an ip-core from the library to the SOC
- <<id>> : id of the IP core
- <<name>> : instanciation name
" > add <<core>> <<version>> <<name>>
# adds a ip-core from the library to the SOC
- <<core>> : name of the IP core
- <<version>> : version of the IP core
- <<name>> : instanciation name
 
"
def do_add( args )
if args.size != 2
puts "two arguments are required:\nusage:\n#{ADD_USAGE}"
if args.size != 3
puts "three arguments are required:\nusage:\n#{ADD_USAGE}"
else
puts FMSG if @soc.add_core( args[ 0 ], args[ 1 ] ) == nil
puts FMSG if @soc.add_core( args[ 0 ], args[ 1 ], args[ 2 ] ) == nil
end
end
 
/soc_maker/trunk/spec/lib_spec.rb
111,33 → 111,21
describe "library access" do
it "should be possible to add, get and remove a core" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
c = SOCMaker::CoreDef.new( "A core", "acore,v1", file, "top" )
c = SOCMaker::CoreDef.new( "acore", "v1", file, "top" )
@lib.add_core( c )
@lib.get_core( "acore,v1" ).should be == c
@lib.get_core( "acore", "v1" ).should be == c
@lib.rm_core( c )
expect { @lib.get_core( "acore,v1" ) }.
expect { @lib.get_core( "acore", "v1" ) }.
to raise_error( SOCMaker::ERR::LibError )
end
 
it "should be possible to add, get and remove an interface" do
i = SOCMaker::IfcSpc.new( "My Interface", "myifc,v2" )
 
# removing with instance
i = SOCMaker::IfcSpc.new( "myifc", "v2" )
@lib.add_ifc( i )
@lib.get_ifc( "myifc,v2" ).should be == i
@lib.get_ifc( "myifc", "v2" ).should be == i
@lib.rm_ifc( i )
 
expect { @lib.get_ifc( "myifc,v2" ) }.
expect { @lib.get_ifc( "myifc", "v2" ) }.
to raise_error( SOCMaker::ERR::LibError )
 
# removing with id
@lib.add_ifc( i )
@lib.get_ifc( "myifc,v2" ).should be == i
@lib.rm_ifc( i.id )
 
expect { @lib.get_ifc( "myifc,v2" ) }.
to raise_error( SOCMaker::ERR::LibError )
 
end
 
it "should process all folders in add_include" do
155,9 → 143,9
 
it "should load all elements from our test library" do
@lib.refresh( './spec/test_soc_lib' )
core_A = @lib.get_core( "core_A,rel1" )
core_B = @lib.get_core( "core_B,rel1" )
core_AB_ifc = @lib.get_ifc( "core_AB_ifc,1" )
core_A = @lib.get_core( "core_A", "rel1" )
core_B = @lib.get_core( "core_B", "rel1" )
core_AB_ifc = @lib.get_ifc( "core_AB_ifc", "1" )
core_A.class.should be SOCMaker::CoreDef
core_B.class.should be SOCMaker::CoreDef
core_AB_ifc.class.should be SOCMaker::IfcSpc
/soc_maker/trunk/spec/soc_def_spec.rb
65,7 → 65,7
FULL_SOC_YAML = '''SOCM_SOC
name: my_soc
description: A test SOC
id: my_soc,rel2
version: rel2
date: 1.1.2014
license: LGPL
licensefile:
79,7 → 79,7
SOC_YAML_WITH_CORE = '''SOCM_SOC
name: my_soc
description: A test SOC
id: my_soc,rel2
version: rel2
date: 1.1.2014
license: LGPL
licensefile:
125,9 → 125,9
before( :each )do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
SOCMaker::lib.add_core( core )
@soc = SOCMaker::SOCDef.new( "Test SOC", "test-soc,v1", "my_soc_top" )
@soc = SOCMaker::SOCDef.new( "test-soc", "v1", "my_soc_top" )
end
 
describe "adding/removing cores, connections etc." do
170,11 → 170,11
 
it "should return nil if a instance is added twice" do
@soc.cores[ :core_inst ] = SOCMaker::CoreInst.new( "mycorerel1" )
@soc.add_core( "mycore,rel1", "core_inst" ).should be == false
@soc.add_core( "mycore", "rel1", "core_inst" ).should be == false
end
 
it "should return non-nil value, if a instance is added once" do
@soc.add_core( "mycore,rel1", "core_inst" ).should_not be == false
@soc.add_core( "mycore", "rel1", "core_inst" ).should_not be == false
end
 
# in one of the first version, we returned nil, but now this is
185,7 → 185,7
end
 
it "should raise a library error when adding an unknown core" do
expect{ @soc.add_core( "some_unknown_core,v_xyz", "test" ) }.
expect{ @soc.add_core( "some_unknown_core", "v_xyz", "test" ) }.
to raise_error( SOCMaker::ERR::LibError )
end
 
228,8 → 228,8
end
 
it "should raise an ProcessingError if a interface doesn't exist" do
@soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycore,rel1" )
@soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycore,rel1" )
@soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "mycorerel1" )
@soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "mycorerel1" )
expect{ @soc.add_connection( "core_a", "ifc_a", "core_b", "ifc_c", "a_new_con" ) }.
to raise_error( SOCMaker::ERR::ProcessingError )
end
237,13 → 237,13
 
it "should raise an ProcessingError if the ifc.-version is wrong" do
 
ifc_spc1 = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
ifc_spc2 = SOCMaker::IfcSpc.new( "myifc", "myifc,v2", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v2", 1, { b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_spc1 = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
ifc_spc2 = SOCMaker::IfcSpc.new( "myifc", "v2", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ) } )
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v2", 1, { b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "core_a,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "top" )
core_a.interfaces[ :ifc_a ] = ifc_def_0
core_a.interfaces[ :ifc_b ] = ifc_def_1
core_b.interfaces[ :ifc_a ] = ifc_def_0
253,8 → 253,8
SOCMaker::lib.add_ifc( ifc_spc2 )
SOCMaker::lib.add_core( core_a )
SOCMaker::lib.add_core( core_b )
@soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "core_b,v1" )
@soc.cores[ :core_a ] = SOCMaker::CoreInst.new( "core_av1" )
@soc.cores[ :core_b ] = SOCMaker::CoreInst.new( "core_bv1" )
expect { @soc.add_connection( "inst_a", "ifc_a", "inst_b", "ifc_b", "a_new_con" ) }.
to raise_error( SOCMaker::ERR::ProcessingError )
end
264,18 → 264,18
 
it "should add a connection entry" do
 
ifc_spc = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
ifc_spc = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: {dir:1}, port_b: {dir:0} } )
 
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
 
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
 
 
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "core_b,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "top" )
core_a.interfaces[ :ifc_a ] = ifc_def_0
core_a.interfaces[ :ifc_b ] = ifc_def_1
core_b.interfaces[ :ifc_a ] = ifc_def_0
287,8 → 287,8
 
 
 
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_b ] = SOCMaker::CoreInst.new( "core_b,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
@soc.cores[ :inst_b ] = SOCMaker::CoreInst.new( "core_bv1" )
@soc.consistency_check
@soc.add_connection( "inst_a", "ifc_a", "inst_b", "ifc_b", "a_new_con" )
@soc.cons[ :a_new_con ].should be == { rule:'or', mapping: [ {inst_a: :ifc_a},{inst_b: :ifc_b} ] }
308,7 → 308,7
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
 
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
core_a.interfaces[ :ifc_a ] = ifc_def_0
core_a.interfaces[ :ifc_b ] = ifc_def_1
318,10 → 318,10
 
SOCMaker::lib.add_core( @soc )
@soc.interfaces[ :t1 ] = ifc_def_1
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
@soc.consistency_check
@soc.add_connection( "inst_a", "ifc_a", @soc.id, "t1", "a_new_con" )
@soc.cons[ :a_new_con ].should be == { rule:'or', mapping: [ {inst_a: :ifc_a},{ @soc.id.to_sym => :t1} ] }
@soc.add_connection( "inst_a", "ifc_a", @soc.name, "t1", "a_new_con" )
@soc.cons[ :a_new_con ].should be == { rule:'or', mapping: [ {inst_a: :ifc_a},{ @soc.name.to_sym => :t1} ] }
end
 
 
342,7 → 342,7
parameter = SOCMaker::Parameter.new( "integer" )
core_a.inst_parameters[ :p1 ] = parameter
SOCMaker::lib.add_core( core_a )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
expect{ @soc.set_param( "inst_a", "px", 1234 ) }.
to raise_error( SOCMaker::ERR::ProcessingError )
expect{ @soc.get_param( "inst_a", "px" ) }.
351,11 → 351,11
it "should set a parameter and provide a parameter" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
parameter = SOCMaker::Parameter.new( "integer" )
core_a.inst_parameters[ :p1 ] = parameter
SOCMaker::lib.add_core( core_a )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
@soc.set_param( "inst_a", "p1", 1234 )
@soc.cores[ :inst_a ].params[ :p1 ].should be == 1234
@soc.get_param( "inst_a", "p1" ).should be == 1234
376,13 → 376,13
it "should an error, a static parameter doesn't exist" do
 
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
SOCMaker::lib.add_core( core_a )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
 
expect{ @soc.set_sparam( "core_a,v1", "p1", 1234 ) }.
expect{ @soc.set_sparam( "core_av1", "p1", 1234 ) }.
to raise_error( SOCMaker::ERR::ProcessingError )
expect{ @soc.get_sparam( "core_a,v1", "p1" ) }.
expect{ @soc.get_sparam( "core_av1", "p1" ) }.
to raise_error( SOCMaker::ERR::ProcessingError )
end
 
389,7 → 389,7
it "should set a static-parameter and provide this static parameter" do
 
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
pentry = SOCMaker::SParameterEntry.new( "integer", "TOK" )
parameter = SOCMaker::SParameter.new( "file/path.vhd.src",
"file/path.vhd",
396,11 → 396,11
'parameters' => { p1: pentry } )
core_a.static_parameters[ :p1 ] = parameter
SOCMaker::lib.add_core( core_a )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_a,v1" )
@soc.cores[ :inst_a ] = SOCMaker::CoreInst.new( "core_av1" )
 
@soc.set_sparam( "core_a,v1", "p1", 1234 )
@soc.static[ "core_a,v1".to_sym ][ :p1 ].should be == 1234
@soc.get_sparam( "core_a,v1", "p1" ).should be == 1234
@soc.set_sparam( "core_av1", "p1", 1234 )
@soc.static[ :core_av1 ][ :p1 ].should be == 1234
@soc.get_sparam( "core_av1", "p1" ).should be == 1234
end
 
 
/soc_maker/trunk/spec/component_spec.rb
66,23 → 66,43
to raise_error( SOCMaker::ERR::ValueError )
end
 
# test the id
it "should raise an error, if the id is nil" do
it 'should raise an error, if the name doesnt start with [a-zA-Z]' do
expect{ SOCMaker::Component.new( "4abc", "v1", "top" ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
 
it 'should raise an error, if the name conatins invalid symbols' do
expect{ SOCMaker::Component.new( "abc$abc", "v1", "top" ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
 
 
 
 
 
# test the version
it "should raise an error, if the version is nil" do
expect{ SOCMaker::Component.new( "acore", nil, "top" ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
 
it "should raise an error, if the id has zero-length" do
it "should raise an error, if the version has zero-length" do
expect{ SOCMaker::Component.new( "acore", "", "top" ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
it "should raise an error, if the id is not of type string " do
it "should raise an error, if the version is not of type string neither of type Numerical" do
expect{ SOCMaker::Component.new( "acore", [ 1, 2, 3 ], "top" ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
 
it "should cast a numerical version to a string version" do
c = SOCMaker::Component.new( "acore", 3, "top" )
c.class.should be == SOCMaker::Component
c.version = "3"
end
 
 
%w[ description date license licensefile
author authormail vccmd ].each do |m|
it "should auto-set #{m} to an empty string" do
130,7 → 150,6
 
it 'should iterate over all generics (inst. parameters)' do
 
 
p1 = SOCMaker::Parameter.new( "integer" )
p2 = SOCMaker::Parameter.new( "string" )
p3 = SOCMaker::Parameter.new( "integer" )
161,8 → 180,8
it 'should iterate over all ports' do
 
SOCMaker::lib.clear
ifc_s1 = SOCMaker::IfcSpc.new( "Interface 1", "i1,v1", 'ports' => { p1:{dir:1}, p2:{dir:1}, p3:{dir:0} } )
ifc_s2 = SOCMaker::IfcSpc.new( "Interface 2", "i2,v1", 'ports' => { x1:{dir:1}, x2:{dir:0} } )
ifc_s1 = SOCMaker::IfcSpc.new( "i1", "v1", 'ports' => { p1:{dir:1}, p2:{dir:1}, p3:{dir:0} } )
ifc_s2 = SOCMaker::IfcSpc.new( "i2", "v1", 'ports' => { x1:{dir:1}, x2:{dir:0} } )
SOCMaker::lib.add_ifc( ifc_s1 )
SOCMaker::lib.add_ifc( ifc_s2 )
 
172,11 → 191,11
x1 = SOCMaker::IfcPort.new( "x1", 1 )
x2 = SOCMaker::IfcPort.new( "x2", 2 )
 
ifc_d1 = SOCMaker::IfcDef.new( "i1", "i1,v1", 0, { m_p1: p1, m_p2: p2, m_p3: p3 } )
ifc_d2 = SOCMaker::IfcDef.new( "i2", "i2,v1", 0, { m_x1: x1, m_x2: x2 } )
ifc_d1 = SOCMaker::IfcDef.new( "i1", "v1", 0, { m_p1: p1, m_p2: p2, m_p3: p3 } )
ifc_d2 = SOCMaker::IfcDef.new( "i2", "v1", 0, { m_x1: x1, m_x2: x2 } )
 
c = SOCMaker::Component.new( "A core", "acore,v1", "top",
c = SOCMaker::Component.new( "acore", "v1", "top",
{ 'interfaces' => { i1: ifc_d1, i2: ifc_d2 } } )
 
r_name = []
200,6 → 219,7
r_name = []
r_dir = []
 
p c.interfaces
c.ports( "i1" ) do |arg_name,arg_dir, arg_default, arg_is_last|
#r_def << arg_def
r_name << arg_name
/soc_maker/trunk/spec/core_def_spec.rb
65,7 → 65,7
FULL_YAML = '''SOCM_CORE
name: core_A
description: A test IP-core
id: core_A,rel1
version: rel1
date: 1.1.2014
license: LGPL
licensefile:
77,7 → 77,7
:ifc01: SOCM_IFC
name: core_AB_ifc
dir: 0
id: core_AB_ifc,1
version: "1"
ports:
:sig_con1a: SOCM_PORT
defn: sig_a
121,7 → 121,7
# minimalistic def with one vhdl file
MIN_YAML1 = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
135,7 → 135,7
# vhdl and one verilog file
MIN_YAML2 = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
185,7 → 185,7
# def with toplevel.size == 0
F_YAML_TOPLEVEL = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: ''
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
199,7 → 199,7
# def with hdlfiles.class != Hash
F_YAML_FILE_HASH = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
- test1.vhd
214,7 → 214,7
# minimal setup with one interface
MIN_YAML_IFC = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
223,7 → 223,7
:ifc01: SOCM_IFC
name: a_ifc_def
dir: 0
id: a_ifc_def,1
version: "1"
ports:
:sig_con1a: SOCM_PORT
defn: sig_a
238,7 → 238,7
# minimal setup with one instance parameter
MIN_YAML_INSTP = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
254,7 → 254,7
# empty hash for param1
F_YAML_INSTP_EMPTY = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
268,7 → 268,7
# minimal def with one static parameter
MIN_YAML_STATIC = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
290,7 → 290,7
# empty static parameter
F_YAML_STATIC_EMPTY = '''SOCM_CORE
name: core_A
id: core_A,rel1
version: rel1
toplevel: top_A
hdlfiles:
:core_a.vhd: SOCM_HDL_FILE
315,7 → 315,7
 
it "should return a CoreDef object, if the object is created via new" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
c = SOCMaker::CoreDef.new( "acore", "acore,v1", file, "top" )
c = SOCMaker::CoreDef.new( "acore", "v1", file, "top" )
c.class.should be == SOCMaker::CoreDef
end
475,7 → 475,7
 
it "should be possible to encode and decode a core definition" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
o1 = SOCMaker::CoreDef.new( "acore", "acore,v1", file, "top" )
o1 = SOCMaker::CoreDef.new( "acore", "v1", file, "top" )
yaml_str = o1.to_yaml
o2 = YAML::load( yaml_str )
o1.should be == o2
483,9 → 483,9
 
it "should return false for two non-equal objects" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
o1 = SOCMaker::CoreDef.new( "acore", "acore,v1", file, "top" )
o1 = SOCMaker::CoreDef.new( "acore", "v1", file, "top" )
o2 = Marshal::load(Marshal.dump(o1))
o2.id = "acore,v2"
o2.version = "v2"
( o2 == o1 ).should be == false
o2 = Marshal::load(Marshal.dump(o1))
o2.hdlfiles[ "file.vhd".to_sym ].use_syn = false
/soc_maker/trunk/spec/ifc_spc_spec.rb
49,7 → 49,7
IFC_YAML_VALID = """
SOCM_IFC_SPC
name: core_ifc
id: 'core_ifc,1'
version: '1'
ports:
:sig_a:
:dir: 1
62,7 → 62,7
IFC_YAML_INVALID = """
SOCM_IFC_SPC
:name: core_ifc
:id: 'core_ifc,1'
:version: '1'
:ports:
:sig_a: '12'
:sig_b: 1
72,7 → 72,7
IFC_YAML_INVALID2 = """
SOCM_IFC_SPC
:name: core_ifc
:id: 'core_ifc,1'
:version: '1'
:ports:
:sig_a:
:sig_b: 1
94,12 → 94,12
to raise_error( SOCMaker::ERR::ValueError )
end
it "should raise an error if the id is not a string" do
it "should raise an error if the version is not a string" do
expect{ SOCMaker::IfcSpc.new( "myifc", 234, { :p1 => "a-string" } ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
it "should raise an error if the id is an a empty string" do
it "should raise an error if the version is an a empty string" do
expect{ SOCMaker::IfcSpc.new( "myifc", "", { :p1 => "a-string" } ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
106,7 → 106,7
it "should raise an error if a port direction is neither 0 nor 1" do
expect{ SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { :p1 => "a-string" } ) }.
expect{ SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { :p1 => "a-string" } ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
/soc_maker/trunk/spec/test_soc.yaml
1,7 → 1,7
SOCM_SOC
name: test_soc
description: 'This is a test SOC'
id: test_soc,v1
version: v1
date: '13. May 2014'
license: 'GPL'
licensefile: ''
12,7 → 12,7
:top_ifc: SOCM_IFC
name: core_AB_ifc
dir: 0
id: core_AB_ifc,1
version: "1"
ports:
:sig_con1a: SOCM_PORT
defn: sig_a
29,22 → 29,22
static_parameters: {}
cores:
:inst_a: SOCM_INST
type: core_A,rel1
type: core_Arel1
params:
:param1: 8
:param2: 8
:param3: 16
:inst_b: SOCM_INST
type: core_A,rel1
type: core_Arel1
params:
:param1: 8
:param2: 16
:param3: 16
:inst_c: SOCM_INST
type: core_B,rel1
type: core_Brel1
params: {}
:inst_d: SOCM_INST
type: core_B,rel1
type: core_Brel1
params: {}
 
static:
/soc_maker/trunk/spec/core_inst_spec.rb
56,10 → 56,10
 
it "should raise an error, if parameters are given, which doesn't exist in the definition" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
SOCMaker::lib.add_core( core )
expect{
inst = SOCMaker::CoreInst.new( "mycore,rel1", { "aparameter".to_sym => 4 } )
inst = SOCMaker::CoreInst.new( "mycorerel1", { "aparameter".to_sym => 4 } )
inst.consistency_check }.
to raise_error( SOCMaker::ERR::ValueError )
SOCMaker::lib.rm_core( core )
71,11 → 71,11
# create core with one file and one instance parameter
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
parameters = { "param1".to_sym => SOCMaker::Parameter.new( "integer" ) }
core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
core.inst_parameters = parameters
SOCMaker::lib.add_core( core )
 
inst = SOCMaker::CoreInst.new( "mycore,rel1", {} )
inst = SOCMaker::CoreInst.new( "mycorerel1", {} )
inst.consistency_check
inst.params[ :param1 ].should be == 0
SOCMaker::lib.rm_core( core )
88,7 → 88,7
# it 'should return true and false for implements_port?, when a port is implemented and
# not implemented' do
# file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
# core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
# core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
# ifc_spc = SOCMaker::IfcSpc.new( "a_ifc", "v1", "ports" => { p1: 1, p2: 0 } )
# ifc = SOCMaker::IfcDef.new( "a_ifc", "v1", 1, { p1: SOCMaker::IfcPort.new( "p1", 1 ) } )
# core.interfaces[ :i1 ] = ifc
95,7 → 95,7
# SOCMaker::lib.add_core( core )
# SOCMaker::lib.add_ifc( ifc_spc )
 
# o1 = SOCMaker::CoreInst.new( "mycore,rel1", {} )
# o1 = SOCMaker::CoreInst.new( "mycorerel1", {} )
# o1.consistency_check
# o1.implements_port?( 'i1', 'p1' ).should be == true
# o1.implements_port?( 'i1', 'p2' ).should be == false
107,11 → 107,11
it "should be possible to encode and decode a core instance" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
parameters = { "param1".to_sym => SOCMaker::Parameter.new( "integer" ) }
core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
core.inst_parameters = parameters
SOCMaker::lib.add_core( core )
 
o1 = SOCMaker::CoreInst.new( "mycore,rel1", {} )
o1 = SOCMaker::CoreInst.new( "mycorerel1", {} )
yaml_str = o1.to_yaml
o2 = YAML::load( yaml_str )
o1.should be == o2
120,11 → 120,11
it "should return false for two non-equal objects" do
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
parameters = { "param1".to_sym => SOCMaker::Parameter.new( "integer" ) }
core = SOCMaker::CoreDef.new( "My Core", "mycore,rel1", file, "top" )
core = SOCMaker::CoreDef.new( "mycore", "rel1", file, "top" )
core.inst_parameters = parameters
SOCMaker::lib.add_core( core )
 
o1 = SOCMaker::CoreInst.new( "mycore,rel1" )
o1 = SOCMaker::CoreInst.new( "mycorerel1" )
o1.consistency_check
o2 = Marshal::load(Marshal.dump(o1))
o2.type << "X"
137,7 → 137,7
it "should call coder functions for each core-def. (stub-version)" do
SOCMaker::lib.clear
soc = SOCMaker::SOCDef.new( "test_soc", "test_soc,v1", "my_soc_top" )
soc = SOCMaker::SOCDef.new( "test_soc", "v1", "my_soc_top" )
 
 
coder = double()
175,18 → 175,18
file = { "file.vhd".to_sym => SOCMaker::HDLFile.new( "./file.vhd" ) }
core_a = SOCMaker::CoreDef.new( "core_a", "core_a,v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "core_b,v1", file, "top" )
core_a = SOCMaker::CoreDef.new( "core_a", "v1", file, "top" )
core_b = SOCMaker::CoreDef.new( "core_b", "v1", file, "top" )
SOCMaker::lib.add_core( core_a )
SOCMaker::lib.add_core( core_b )
ifc_spc = SOCMaker::IfcSpc.new( "myifc", "myifc,v1", 'ports' => { port_a: { dir: 1}, port_b: { dir: 0 } } )
ifc_spc = SOCMaker::IfcSpc.new( "myifc", "v1", 'ports' => { port_a: { dir: 1}, port_b: { dir: 0 } } )
SOCMaker::lib.add_ifc( ifc_spc )
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_def_1 = SOCMaker::IfcDef.new( "myifc", "v1", 0, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
ifc_def_0 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { a: SOCMaker::IfcPort.new( "port_a", 1 ),
b: SOCMaker::IfcPort.new( "port_b", 1 ) } )
core_a.interfaces[ :ifc_a ] = ifc_def_0
195,10 → 195,10
core_b.interfaces[ :ifc_b ] = ifc_def_1
i1 = SOCMaker::CoreInst.new( "core_a,v1" )
i2 = SOCMaker::CoreInst.new( "core_a,v1" )
i3 = SOCMaker::CoreInst.new( "core_b,v1" )
i4 = SOCMaker::CoreInst.new( "core_b,v1" )
i1 = SOCMaker::CoreInst.new( "core_av1" )
i2 = SOCMaker::CoreInst.new( "core_av1" )
i3 = SOCMaker::CoreInst.new( "core_bv1" )
i4 = SOCMaker::CoreInst.new( "core_bv1" )
soc.cores[ :inst_a ] = i1
soc.cores[ :inst_b ] = i2
209,7 → 209,7
 
SOCMaker::lib.add_core( soc )
soc_inst = SOCMaker::CoreInst.new( 'test_soc,v1' )
soc_inst = SOCMaker::CoreInst.new( 'test_socv1' )
soc_inst.consistency_check
 
soc_inst.stub( :gen_toplevel_con ) do |name_arg,
228,7 → 228,7
File.should_receive(:open).and_yield(file_mock)
soc_inst.gen_toplevel( coder );
added_cores.should be == { "core_a,v1".to_sym => core_a, "core_b,v1".to_sym => core_b }
added_cores.should be == { :core_av1 => core_a, :core_bv1 => core_b }
added_instances.should be == { inst_a: i1, inst_b: i2, inst_c: i3, inst_d: i4 }
added_cons.should be == { a_new_con: { rule: "or", m0: {inst_a: :ifc_a}, m1: {inst_b: :ifc_b } } }
dir_path.should be == dir_path_ref
245,7 → 245,7
SOCMaker::lib.refresh( './spec/test_soc_lib' )
soc = SOCMaker::from_f( './spec/test_soc.yaml' );
SOCMaker::lib.add_core( soc )
soc_inst = SOCMaker::CoreInst.new( 'test_soc,v1' )
soc_inst = SOCMaker::CoreInst.new( 'test_socv1' )
soc_inst.consistency_check
soc_inst.gen_toplevel( coder );
soc.copy_files
/soc_maker/trunk/spec/test_soc_lib/ifcs/core_AB_ifc/top_ifc.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: Top IFC
id: top_ifc,1
name: top_ifc
version: "1"
ports:
:sig_1:
:dir: 1
/soc_maker/trunk/spec/test_soc_lib/ifcs/core_AB_ifc/core_AB_ifc.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: Core AB Interface
id: core_AB_ifc,1
name: core_AB_ifc
version: "1"
ports:
:sig_a:
:dir: 1
/soc_maker/trunk/spec/test_soc_lib/cores/core_A_rel1/00_core_a.yaml
1,7 → 1,7
SOCM_CORE
name: Core A
description: A test IP-core, which has no functionallity
id: core_A,rel1
name: core_A
description: A test IP-core
version: rel1
date: 1.1.2014
license: LGPL
licensefile:
13,7 → 13,7
:ifc01: SOCM_IFC
name: core_AB_ifc
dir: 0
id: core_AB_ifc,1
version: "1"
ports:
:sig_con1a: SOCM_PORT
defn: sig_a
27,7 → 27,7
:ifc02: SOCM_IFC
name: core_AB_ifc
dir: 1
id: core_AB_ifc,1
version: "1"
ports:
:sig_con1ax: SOCM_PORT
defn: sig_a
/soc_maker/trunk/spec/test_soc_lib/cores/core_B_rel1/core_b.yaml
1,7 → 1,7
SOCM_CORE
name: Core B
name: core_B
description: B test IP-core
id: core_B,rel1
version: rel1
date: 1.1.2014
license: LGPL
licensefile:
13,7 → 13,7
:myifc: SOCM_IFC
name: core_AB_ifc
dir: 1
id: core_AB_ifc,1
version: "1"
ports:
:mysig_con1a: SOCM_PORT
defn: sig_a
/soc_maker/trunk/spec/ifc_def_spec.rb
46,42 → 46,46
tmp_port = SOCMaker::IfcPort.new( "abc" )
 
it "should return a SOCMaker::IfcDef object when creating with new" do
s = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { test: tmp_port } )
s = SOCMaker::IfcDef.new( "myifc", "v1", 1, { test: tmp_port } )
s.class.should be SOCMaker::IfcDef
end
 
it "should raise an error if the name is not a string" do
expect{ SOCMaker::IfcDef.new( 4, "myifc,v1", 1, { test: tmp_port } ) }.
expect{ SOCMaker::IfcDef.new( 4, "v1", 1, { test: tmp_port } ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
it "should raise an error if the direction is neither 0 nor 1 " do
expect{ SOCMaker::IfcDef.new( "myifc", "myifc,v1", 4, { test: tmp_port } ) }.
expect{ SOCMaker::IfcDef.new( "myifc", "v1", 4, { test: tmp_port } ) }.
to raise_error( SOCMaker::ERR::ValueError )
end
 
 
it "should raise an error if no ports are given " do
expect{ SOCMaker::IfcDef.new( "myifc", "myifc,v1", 4, { } ) }.
expect{ SOCMaker::IfcDef.new( "myifc", "v1", 4, { } ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
 
 
it "should raise an error if a ports is nil " do
expect{ SOCMaker::IfcDef.new( "myifc", "myifc,v1", 4, { a_port: nil} ) }.
expect{ SOCMaker::IfcDef.new( "myifc", "v1", 4, { a_port: nil} ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
 
it "should raise an error if a ports is not of type SOCMaker::IfcPort " do
expect{ SOCMaker::IfcDef.new( "myifc", "myifc,v1", 4, { a_port: "string-type"} ) }.
expect{ SOCMaker::IfcDef.new( "myifc", "v1", 4, { a_port: "string-type"} ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
 
it "should raise an error if no ports are given (nil)" do
expect{ SOCMaker::IfcDef.new( "myifc", "myifc,v1", 4, nil ) }.
expect{ SOCMaker::IfcDef.new( "myifc", "v1", 4, nil ) }.
to raise_error( SOCMaker::ERR::StructureError )
end
 
it "should auto-convert a numerical version to string version" do
s = SOCMaker::IfcDef.new( "myifc", 1, 1, { test: tmp_port } )
s.version.should be == "1"
end
end
 
describe SOCMaker::IfcDef, "object handling, en-decoding:" do
88,14 → 92,14
tmp_port = SOCMaker::IfcPort.new( "abc" )
 
it "should return false for two non-equal objects" do
o1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { test: tmp_port } )
o1 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { test: tmp_port } )
o2 = Marshal::load(Marshal.dump(o1))
o2.id = "myifc,v2"
o2.version = "v2"
( o2 == o1 ).should be == false
end
 
it "should be possible to encode and decode a interface definition" do
o1 = SOCMaker::IfcDef.new( "myifc", "myifc,v1", 1, { test: tmp_port } )
o1 = SOCMaker::IfcDef.new( "myifc", "v1", 1, { test: tmp_port } )
yaml_str = o1.to_yaml
o2 = YAML::load( yaml_str )
o1.should be == o2
/soc_maker/trunk/examples/or1200_test/or1200_test.rb
19,21 → 19,21
# core.update_vcs
end
 
soc = SOCMaker::SOCDef.new( 'OR1200 Test SOC', 'or1200_test,v1', 'or1200_test' )
soc = SOCMaker::SOCDef.new( 'or1200_test', 'v1', 'or1200_test' )
SOCMaker::lib.add_core( soc )
soc_inst = SOCMaker::CoreInst.new( 'or1200_test,v1' )
soc_inst = SOCMaker::CoreInst.new( 'or1200_testv1' )
#soc_inst.name = "soc_inst"
 
 
port = SOCMaker::IfcPort.new( 'clk', 1 )
ifc = SOCMaker::IfcDef.new( 'clk', 'clk,1', 1, { 'clk_i' => port} )
ifc = SOCMaker::IfcDef.new( 'clk', '1', 1, { 'clk_i' => port} )
soc.interfaces[ 'clk_ifc'.to_sym ] = ifc
 
port = SOCMaker::IfcPort.new( 'rst', 1 )
ifc = SOCMaker::IfcDef.new( 'rst', 'rst,1', 1, { 'rst_i' => port} )
ifc = SOCMaker::IfcDef.new( 'rst', '1', 1, { 'rst_i' => port} )
soc.interfaces[ 'rst_ifc'.to_sym ] = ifc
 
soc.interfaces[ 'jtag_ifc'.to_sym ] = SOCMaker::IfcDef.new( 'jtag_tap', 'jtag_tap,1', 1, {
soc.interfaces[ 'jtag_ifc'.to_sym ] = SOCMaker::IfcDef.new( 'jtag_tap', '1', 1, {
'tck_i' => SOCMaker::IfcPort.new( 'tck', 1 ),
'tdi_i' => SOCMaker::IfcPort.new( 'tdi', 1 ),
'tdo_o' => SOCMaker::IfcPort.new( 'tdo' ,1 ),
44,7 → 44,7
'capture_dr_i' => SOCMaker::IfcPort.new( 'capture', 1 ),
'debug_select_i' => SOCMaker::IfcPort.new( 'select', 1 ) } )
 
soc.interfaces[ 'uart_ifc'.to_sym ] = SOCMaker::IfcDef.new( 'uart', 'uart,1', 1, {
soc.interfaces[ 'uart_ifc'.to_sym ] = SOCMaker::IfcDef.new( 'uart', '1', 1, {
'stx_pad_o' => SOCMaker::IfcPort.new( 'stx_pad', 1 ),
'srx_pad_i' => SOCMaker::IfcPort.new( 'srx_pad', 1 ),
'rts_pad_o' => SOCMaker::IfcPort.new( 'rts_pad', 1 ),
55,12 → 55,12
'dcd_pad_i' => SOCMaker::IfcPort.new( 'dcd_pad', 1 ) } )
 
 
soc.add_core( 'or1200,rel2', 'cpu' )
soc.add_core( 'wb_connect,1', 'wb_bus' )
soc.add_core( 'adv_debug_sys,ads_3', 'dbg' )
soc.add_core( 'ram_wb,b3', 'ram1' )
soc.add_core( 'ram_wb,b3', 'ram2' )
soc.add_core( 'uart16550,rel4', 'uart' )
soc.add_core( 'or1200', 'rel2', 'cpu' )
soc.add_core( 'wb_connect', '1', 'wb_bus' )
soc.add_core( 'adv_debug_sys', 'ads_3', 'dbg' )
soc.add_core( 'ram_wb', 'b3', 'ram1' )
soc.add_core( 'ram_wb', 'b3', 'ram2' )
soc.add_core( 'uart16550', 'rel4', 'uart' )
soc.consistency_check
 
 
67,34 → 67,34
#
# Setup the CPU
#
soc.set_sparam( 'or1200,rel2', 'VCD_DUMP', false )
soc.set_sparam( 'or1200,rel2', 'VERBOSE', false )
soc.set_sparam( 'or1200,rel2', 'ASIC' , false )
soc.set_sparam( 'or1200rel2', 'VCD_DUMP', false )
soc.set_sparam( 'or1200rel2', 'VERBOSE', false )
soc.set_sparam( 'or1200rel2', 'ASIC' , false )
 
soc.set_sparam( 'or1200,rel2', 'ASIC_MEM_CHOICE', 0 )
soc.set_sparam( 'or1200,rel2', 'ASIC_NO_DC', true )
soc.set_sparam( 'or1200,rel2', 'ASIC_NO_IC', true )
soc.set_sparam( 'or1200,rel2', 'ASIC_NO_DMMU', true )
soc.set_sparam( 'or1200,rel2', 'ASIC_NO_IMMU', true )
soc.set_sparam( 'or1200,rel2', 'ASIC_MUL_CHOICE', 0 )
soc.set_sparam( 'or1200,rel2', 'ASIC_IC_CHOICE', 0 )
soc.set_sparam( 'or1200,rel2', 'ASIC_DC_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'ASIC_MEM_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'ASIC_NO_DC', true )
soc.set_sparam( 'or1200rel2', 'ASIC_NO_IC', true )
soc.set_sparam( 'or1200rel2', 'ASIC_NO_DMMU', true )
soc.set_sparam( 'or1200rel2', 'ASIC_NO_IMMU', true )
soc.set_sparam( 'or1200rel2', 'ASIC_MUL_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'ASIC_IC_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'ASIC_DC_CHOICE', 0 )
 
 
soc.set_sparam( 'or1200,rel2', 'FPGA_MEM_CHOICE', 0 )
soc.set_sparam( 'or1200,rel2', 'FPGA_NO_DC', true )
soc.set_sparam( 'or1200,rel2', 'FPGA_NO_IC', true )
soc.set_sparam( 'or1200,rel2', 'FPGA_NO_DMMU', true )
soc.set_sparam( 'or1200,rel2', 'FPGA_NO_IMMU', true )
soc.set_sparam( 'or1200,rel2', 'FPGA_MUL_CHOICE', 1 )
soc.set_sparam( 'or1200,rel2', 'FPGA_IC_CHOICE', 0 )
soc.set_sparam( 'or1200,rel2', 'FPGA_DC_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'FPGA_MEM_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'FPGA_NO_DC', true )
soc.set_sparam( 'or1200rel2', 'FPGA_NO_IC', true )
soc.set_sparam( 'or1200rel2', 'FPGA_NO_DMMU', true )
soc.set_sparam( 'or1200rel2', 'FPGA_NO_IMMU', true )
soc.set_sparam( 'or1200rel2', 'FPGA_MUL_CHOICE', 1 )
soc.set_sparam( 'or1200rel2', 'FPGA_IC_CHOICE', 0 )
soc.set_sparam( 'or1200rel2', 'FPGA_DC_CHOICE', 0 )
 
#
# Setup the on-chip memory
#
soc.set_sparam( 'ram_wb,b3', 'MEM_SIZE', 10 )
soc.set_sparam( 'ram_wb,b3', 'MEM_ADR_WIDTH', 14 )
soc.set_sparam( 'ram_wbb3', 'MEM_SIZE', 20 )
soc.set_sparam( 'ram_wbb3', 'MEM_ADR_WIDTH', 17 )
 
 
#
101,10 → 101,10
#
#
 
soc.add_connection( 'clk_ifc', 'cpu', 'clk', 'con_main_clk' )
soc.add_connection( 'rst_ifc', 'cpu', 'rst', 'con_main_rst' )
soc.add_connection( 'clk_ifc', 'wb_bus', 'clk', 'con_main_clk' )
soc.add_connection( 'rst_ifc', 'wb_bus', 'rst', 'con_main_rst' )
soc.add_connection( 'or1200_test', 'clk_ifc', 'cpu', 'clk', 'con_main_clk' )
soc.add_connection( 'or1200_test', 'rst_ifc', 'cpu', 'rst', 'con_main_rst' )
soc.add_connection( 'or1200_test', 'clk_ifc', 'wb_bus', 'clk', 'con_main_clk' )
soc.add_connection( 'or1200_test', 'rst_ifc', 'wb_bus', 'rst', 'con_main_rst' )
 
soc.add_connection( 'wb_bus', 'i3', 'dbg', 'wb_ifc', 'con_wb_debug' )
soc.add_connection( 'wb_bus', 'i4', 'cpu', 'wb_data', 'con_data' )
115,9 → 115,9
 
soc.add_connection( 'dbg', 'cpu0_dbg', 'cpu', 'ext_debug', 'con_debug' )
 
soc.add_connection( 'clk_ifc', 'dbg', 'cpu0_dbg_clk', 'con_main_clk' )
soc.add_connection( 'jtag_ifc', 'dbg', 'jtag', 'con_jtag_top' )
soc.add_connection( 'uart_ifc', 'uart', 'uart_ifc', 'con_uart_top' )
soc.add_connection( 'or1200_test', 'clk_ifc', 'dbg', 'cpu0_dbg_clk', 'con_main_clk' )
soc.add_connection( 'or1200_test', 'jtag_ifc', 'dbg', 'jtag', 'con_jtag_top' )
soc.add_connection( 'or1200_test', 'uart_ifc', 'uart', 'uart_ifc', 'con_uart_top' )
 
soc_inst.consistency_check
soc_inst.gen_toplevel
/soc_maker/trunk/core_lib/interfaces/clk_rst/single.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: single
id: single,1
version: "1"
ports:
:single:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/clk_rst/rst.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: rst
id: rst,1
version: "1"
ports:
:rst:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/clk_rst/clk.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: clk
id: clk,1
version: "1"
ports:
:clk:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/jtag/jtag.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: jtag
id: jtag,1
version: "1"
ports:
:tck:
:dir: 1
/soc_maker/trunk/core_lib/interfaces/jtag/jtag_tap.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: jtag_tap
id: jtag_tap,1
version: "1"
ports:
:tck:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/debug/debug.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: debug
id: debug,1
version: "1"
ports:
:dbg_stall:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/power/or_power.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: or_power_management
id: or_power_management,1
version: "1"
ports:
:pm_cpustall:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/wishbone/wishbone_ma_b3.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: Wishbone Master
id: wishbone_ma,b3
name: wishbone_ma
version: "b3"
ports:
:clk:
:dir: 0
/soc_maker/trunk/core_lib/interfaces/wishbone/wishbone_sl_b3.yaml
1,6 → 1,6
SOCM_IFC_SPC
name: Wishbone Slave
id: wishbone_sl,b3
name: wishbone_sl
version: "b3"
ports:
:clk:
:dir: 0
/soc_maker/trunk/core_lib/cores/or1200_rel2/01_or1200.yaml
1,7 → 1,7
SOCM_CORE
name: OpenRISC 1200
name: or1200
description: OpenRISC CPU
id: or1200,rel2
version: rel2
license: LGPL
licensefile:
author:
12,7 → 12,7
:clmode: SOCM_IFC
name: single
dir: 1
id: single,1
version: "1"
ports:
:clmode_i: SOCM_PORT
len: 2
21,7 → 21,7
:pic_ints: SOCM_IFC
name: single
dir: 1
id: single,1
version: "1"
ports:
:pic_ints_i: SOCM_PORT
len: 20
30,7 → 30,7
:clk: SOCM_IFC
name: clk
dir: 1
id: clk,1
version: "1"
ports:
:clk_i: SOCM_PORT
len: 1
39,7 → 39,7
:rst: SOCM_IFC
name: rst
dir: 1
id: rst,1
version: "1"
ports:
:rst_i: SOCM_PORT
len: 1
48,7 → 48,7
:wb_instruction: SOCM_IFC
name: wishbone_ma
dir: 1
id: wishbone_ma,b3
version: "b3"
ports:
:iwb_clk_i: SOCM_PORT
defn: clk
90,7 → 90,7
:wb_data: SOCM_IFC
name: wishbone_ma
dir: 1
id: wishbone_ma,b3
version: "b3"
ports:
:dwb_clk_i: SOCM_PORT
defn: clk
132,7 → 132,7
:ext_debug: SOCM_IFC
name: debug
dir: 1
id: debug,1
version: "1"
ports:
:dbg_stall_i: SOCM_PORT
defn: dbg_stall
174,7 → 174,7
:pow_man: SOCM_IFC
name: or_power_management
dir: 1
id: or_power_management,1
version: "1"
ports:
:pm_cpustall_i: SOCM_PORT
len: 1
/soc_maker/trunk/core_lib/cores/ram_wb/ram_wb.yaml
1,7 → 1,7
SOCM_CORE
name: Wishbone RAM
name: ram_wb
description: Onchip-RAM
id: ram_wb,b3
version: b3
license: LGPL
licensefile:
author:
11,9 → 11,9
 
interfaces:
:wb_ifc: SOCM_IFC
name: Wishbone IFC
name: wishbone_sl
dir: 1
id: wishbone_sl,b3
version: "b3"
ports:
:wb_adr_i: SOCM_PORT
len: 32
/soc_maker/trunk/core_lib/cores/wb_connect/wb_connect.yaml
1,7 → 1,7
SOCM_CORE
name: wb_connect
description: A block to connect RISC and peripheral controllers together
id: wb_connect,1
version: "1"
license: LGPL
licensefile:
author: Damjan Lampret
13,7 → 13,7
:clk: SOCM_IFC
name: clk
dir: 1
id: clk,1
version: "1"
ports:
:wb_clk_i: SOCM_PORT
len: 1
22,7 → 22,7
:rst: SOCM_IFC
name: rst
dir: 1
id: rst,1
version: "1"
ports:
:wb_rst_i: SOCM_PORT
len: 1
33,7 → 33,7
:i0: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i0_wb_clk_o: SOCM_PORT
defn: clk
71,7 → 71,7
:i1: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i1_wb_clk_o: SOCM_PORT
defn: clk
109,7 → 109,7
:i2: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i2_wb_clk_o: SOCM_PORT
defn: clk
147,7 → 147,7
:i3: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i3_wb_clk_o: SOCM_PORT
defn: clk
185,7 → 185,7
:i4: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i4_wb_clk_o: SOCM_PORT
defn: clk
223,7 → 223,7
:i5: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i5_wb_clk_o: SOCM_PORT
defn: clk
261,7 → 261,7
:i6: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i6_wb_clk_o: SOCM_PORT
defn: clk
299,7 → 299,7
:i7: SOCM_IFC
name: wishbone_ma
dir: 0
id: wishbone_ma,b3
version: "b3"
ports:
:i7_wb_clk_o: SOCM_PORT
defn: clk
337,7 → 337,7
:t0: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t0_wb_clk_o: SOCM_PORT
defn: clk
375,7 → 375,7
:t1: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t1_wb_clk_o: SOCM_PORT
defn: clk
413,7 → 413,7
:t2: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t2_wb_clk_o: SOCM_PORT
defn: clk
451,7 → 451,7
:t3: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t3_wb_clk_o: SOCM_PORT
defn: clk
489,7 → 489,7
:t4: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t4_wb_clk_o: SOCM_PORT
defn: clk
527,7 → 527,7
:t5: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t5_wb_clk_o: SOCM_PORT
defn: clk
565,7 → 565,7
:t6: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t6_wb_clk_o: SOCM_PORT
defn: clk
603,7 → 603,7
:t7: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t7_wb_clk_o: SOCM_PORT
defn: clk
641,7 → 641,7
:t8: SOCM_IFC
name: wishbone_sl
dir: 0
id: wishbone_sl,b3
version: "b3"
ports:
:t8_wb_clk_o: SOCM_PORT
defn: clk
/soc_maker/trunk/core_lib/cores/adv_debug_sys/01_adv_debug_sys.yaml
1,7 → 1,7
SOCM_CORE
name: Advanced Debug System
name: adv_debug_sys
description: Advanced Debug System
id: adv_debug_sys,ads_3
version: ads_3
license: LGPL
licensefile:
author:
16,7 → 16,7
:jtag: SOCM_IFC
name: jtag_tap
dir: 1
id: jtag_tap,1
version: "1"
ports:
:tck_i: SOCM_PORT
len: 1
53,7 → 53,7
:wb_ifc: SOCM_IFC
name: wishbone_ma
dir: 1
id: wishbone_ma,b3
version: "b3"
ports:
:wb_clk_i: SOCM_PORT
len: 1
101,7 → 101,7
:cpu0_dbg_clk: SOCM_IFC
name: clk
dir: 1
id: clk,1
version: "1"
ports:
:cpu0_clk_i: SOCM_PORT
len: 1
110,7 → 110,7
:cpu0_dbg_rst: SOCM_IFC
name: rst
dir: 0
id: rst,1
version: "1"
ports:
:cpu0_rst_o: SOCM_PORT
len: 1
119,7 → 119,7
:cpu0_dbg: SOCM_IFC
name: debug
dir: 0
id: debug,1
version: "1"
ports:
:cpu0_addr_o: SOCM_PORT
len: 32

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.