cross_origen 0.5.0

data/lib/cross_origen/origen_format.rb

@@ -0,0 +1,541 @@
+module CrossOrigen
+  class OrigenFormat
+    require 'nokogiri'
+
+    SUB_BLOCK_ATTRS = {
+      base_address:    'IP base address',
+      byte_order:      'Describes endianness of the IP.  Values possible are :big_endian and :little_endian',
+      lau:             'IP Least Addressable Unit: Values possible are (1..32)',
+      version:         'IP version',
+      instance:        'IP instance',
+      instance_module: 'IP module',
+      class_name:      'Class name',
+      instance:        'IP instance',
+      instance_module: 'IP module',
+      addr_block_name: 'Address block name',
+      space:           'Address block space'
+    }
+
+    FILE_COMMENTS = {
+      class: "\# This file is created by Origen via CrossOrigen::OrigenFormat#export, and is read-only.\n\# If you need to make changes, re-open the class\n",
+      incl:  "\# This file is created by Origen via CrossOrigen::OrigenFormat#export, and is read-only"
+    }
+
+    attr_reader :obj, :top_level_class, :top_level_hierarchy, :output_dir, :top_level_path, :incl_path, :incl_dir, :file_content
+
+    def initialize(options = {})
+      options = {
+        obj:  $dut,
+        path: "#{Origen.root!}/output"
+      }.update(options)
+      @obj = options[:obj]
+      @output_dir = options[:path]
+      @top_level_path = "#{output_dir}/top_level.rb"
+      @incl_path = "#{output_dir}/sub_blocks.rb"
+      @incl_dir = "#{output_dir}/import"
+      @top_level_hierarchy = get_namespace(options)
+      @top_level_class = @top_level_hierarchy.keys.last
+
+      # first key is file type (:bom or :incl) and second is object name
+      @file_content = Hash.new do |h, k|
+        h[k] = {}
+      end
+    end
+
+    def export
+      # Delete any previous files
+      FileUtils.rm_rf(@incl_dir) if File.exist?(@incl_dir)
+      FileUtils.mkdir_p(@incl_dir)
+
+      # Check if previous version of top-level files exist and delete them
+      File.delete(@top_level_path) if File.exist?(@top_level_path)
+      File.delete(@incl_path) if File.exist?(@incl_path)
+
+      # Create the sub_block objects in the top_level.rb file
+      # This method will create each required class file recursively (indirectly)
+      # and will gather all of the information required to create the include file.
+      # In essence it does it all
+      create_bom
+    end
+
+    private
+
+    # Creates the BoM file that creates the sub_blocks from the meta-modelled sub_blocks
+    def create_bom
+      indent = ''
+      file_content = {}
+      full_class = @top_level_hierarchy.keys.last
+      klass = @top_level_class.demodulize
+      Origen.log.info 'Exporting to Origen format...'
+      File.open(@top_level_path, 'w') do |bom_file|
+        # bom_file.chmod(0555)
+        bom_file.puts(FILE_COMMENTS[:incl])
+        bom_file.puts("require_relative 'sub_blocks'")
+        @top_level_hierarchy.each do |name, obj|
+          bom_file.puts("#{indent}#{obj} #{name.split('::').last}")
+          indent += '  '
+        end
+        bom_file.puts("#{indent}include Origen::Model")
+        bom_file.puts('')
+        bom_file.puts("#{indent}def initialize(options = {})")
+        indent += '  '
+        # This method is recursive (indirectly) so file_content should find all BoM and include file strings
+        create_file_content(@obj, indent)
+        @file_content.each do |file_type, str_hash|
+          if file_type == :bom
+            str_hash.each do |_obj, str|
+              bom_file.puts(str)
+            end
+          elsif file_type == :incl
+            # Create the include file
+            File.open(@incl_path, 'w') do |incl_file|
+              str_hash.each do |_obj, str|
+                incl_file.puts(str)
+              end
+            end
+          else
+            Origen.log.error 'Incorrect key for @file_content instance variable Hash, must be :incl or :bom'
+          end
+        end
+        if @obj.owns_registers?
+          @obj.regs.each do |_reg_name, r|
+            reg_path = r.path.gsub(/#{klass}./i, '')
+            reg_path.chop! if reg_path[-1] == '.'
+            r.description.each do |line|
+              bom_file.puts("#{indent}# #{line}")
+            end
+            reg_string = "#{indent}reg :#{r.name}, #{r.address.to_hex}, size: #{r.size}"
+            if r.respond_to? :bit_order
+              if r.bit_order.is_a?(String)
+                reg_string += ", bit_order: '#{r.bit_order}'"
+              elsif r.bit_order.is_a?(Symbol)
+                reg_string += ", bit_order: :#{r.bit_order}"
+              elsif r.bit_order.is_a?(NilClass)
+              # do not add bitorder if it is not available
+              else
+                reg_string += ", bit_order: #{r.bit_order}"
+              end
+            end
+            if r.respond_to? :space
+              if r.space.is_a?(String)
+                reg_string += ", space: '#{r.space}'"
+              elsif r.space.is_a?(Symbol)
+                reg_string += ", space: :#{r.space}"
+              else
+                reg_string += ", space: #{r.space}"
+              end
+            end
+            bom_file.puts("#{reg_string} do |reg|")
+            indent += '  '
+            r.named_bits do |field, bits|
+              if bits.size > 1
+                bit_index = "#{bits.position}..#{bits.position + bits.size - 1}"
+              else
+                bit_index = bits.position.to_s
+              end
+              bits.description.each do |line|
+                bom_file.puts("#{indent}# #{line}")
+              end
+              bom_file.puts("#{indent}reg.bit #{bit_index}, :#{field}, reset: 0b#{bits.reset_val.to_s(2)}, access: :#{bits.access}")
+            end
+            indent = indent[0..-3]
+            bom_file.puts("#{indent}end")
+          end
+        end
+        indent = indent[0..-3]
+        bom_file.puts("#{indent}end")
+        @top_level_hierarchy.each do |_name, _obj|
+          indent = indent[0..-3]
+          bom_file.puts("#{indent}end")
+        end
+      end
+      # Give a newline on console to sepearate out the '.' used for progress indicator
+      puts
+    end
+
+    # Create the bom string for the current object.  Recursive method until no more sub_blocks are found for the current object
+    def create_file_content(obj, indent)
+      unless obj.respond_to?(:sub_blocks) && obj.send(:sub_blocks)
+        Origen.log.warn 'Object argument does not have sub_blocks, ignoring it...'
+        return
+      end
+      obj.sub_blocks.each do |name, sb|
+        @file_content[:bom][name] = "#{indent}sub_block :#{name}"
+        instance_vars_with_content(sb).each do |attr, value|
+          if value.is_a?(String)
+            @file_content[:bom][name] += ", #{attr}: '#{value}'"
+          elsif value.is_a?(Symbol)
+            @file_content[:bom][name] += ", #{attr} = :#{value}"
+          else
+            if attr == :base_address
+              @file_content[:bom][name] += ", #{attr}: #{value.to_hex}"
+            else
+              @file_content[:bom][name] += ", #{attr}: #{value}"
+            end
+          end
+        end
+        @file_content[:bom][name] += ", abs_path: '#{sb.path}'"
+        # Add on the class_name attr as this is not part of the sub_block meta_model
+        class_name = sb.class.to_s.demodulize
+        if class_name == 'SubBlock'
+          file_content[:bom][name] += ", class_name: '#{sb.name.upcase}'"
+        else
+          file_content[:bom][name] += ", class_name: '#{class_name}'"
+        end
+        # Create the class file for this object
+        create_class_file(sb)
+      end
+    end
+
+    def create_class_file(obj)
+      ivars_content = {}
+      ivars_content = instance_vars_with_content(obj)
+      indent = ''
+      klass = get_full_class(obj)
+      class_path_addition = (klass.split('::') - @top_level_class.split('::')).join('/').downcase
+      @file_content[:incl][klass] = "require_relative 'import/#{class_path_addition}'"
+      class_file_name = Pathname.new("#{@incl_dir}/#{class_path_addition}.rb")
+      class_file_dir = class_file_name.dirname
+      unless class_file_dir.exist?
+        Origen.log.debug "app: Directory #{class_file_dir} does not exist, creating it..."
+        FileUtils.mkdir_p(class_file_dir)
+      end
+      File.open(class_file_name, 'w') do |file|
+        # file.chmod(0555)
+        file.puts('# -*- encoding : utf-8 -*-') if RUBY_VERSION < '2.0.0'
+        file.puts(FILE_COMMENTS[:class])
+        # print out the top level object hierarchy
+        @top_level_hierarchy.each do |name, o|
+          file.puts("#{indent}#{o} #{name.split('::').last}")
+          indent += '  '
+        end
+        # print out the current object's sub-hierarchy
+        sub_array = klass.split('::') - @top_level_class.split('::')
+        object_type_array = %w(class) * sub_array.size
+        sub_hierarchy = Hash[sub_array.zip object_type_array]
+        sub_hierarchy.each do |name, o|
+          if o == sub_hierarchy.values.last
+            file.puts("#{indent}#{o} #{name.split('::').last} # rubocop:disable ClassLength")
+          else
+            file.puts("#{indent}#{o} #{name.split('::').last}")
+          end
+          indent += '  '
+        end
+        file.puts("#{indent}include Origen::Model")
+        file.puts('')
+        instance_vars_with_content(obj).each do |attr, _value|
+          file.puts("#{indent}# #{SUB_BLOCK_ATTRS[attr]}")
+          file.puts("#{indent}attr_reader :#{attr}")
+          file.puts('')
+        end
+        file.puts("#{indent}def initialize(options = {})")
+        indent += '  '
+        instance_vars_with_content(obj).each do |attr, value|
+          if value.is_a?(String)
+            file.puts("#{indent}\@#{attr} = '#{value}'")
+          elsif value.is_a?(Symbol)
+            file.puts("#{indent}\@#{attr} = :#{value}")
+          else
+            if attr == :base_address
+              file.puts("#{indent}\@#{attr} = #{value.to_hex}")
+            else
+              file.puts("#{indent}\@#{attr} = #{value}")
+            end
+          end
+        end
+        # If the current object has sub_block they need to be instantiated in the init
+        if obj.respond_to?(:sub_blocks)
+          obj.sub_blocks.each do |n, block|
+            bom_string = "#{indent}sub_block :#{n}"
+            instance_vars_with_content(block).each do |attr, value|
+              if value.is_a?(String)
+                bom_string += ", #{attr}: '#{value}'"
+              elsif value.is_a?(Symbol)
+                bom_string += ", #{attr}: :#{value}"
+              else
+                if attr == :base_address
+                  bom_string += ", #{attr}: #{value.to_hex}"
+                else
+                  bom_string += ", #{attr}: #{value}"
+                end
+              end
+            end
+            bom_string += ", abs_path: '#{block.path}'"
+            # Add on the class_name attr as this is not part of the sub_block meta_model
+            class_name = block.class.to_s.split('::').last
+            if class_name == 'SubBlock'
+              bom_string += ", class_name: '#{block.name.upcase}'"
+            else
+              bom_string += ", class_name: '#{class_name}'"
+            end
+            file.puts(bom_string)
+          end
+        end
+        file.puts("#{indent}instantiate_registers(options)") if obj.owns_registers?
+        indent = indent[0..-3]
+        file.puts("#{indent}end")
+        if obj.owns_registers?
+          file.puts('')
+          file.puts("#{indent}# rubocop:disable LineLength")
+          # Need the register and bit_field descriptions to use double quotes
+          file.puts("#{indent}# rubocop:disable StringLiterals")
+          file.puts("#{indent}def instantiate_registers(options = {}) # rubocop:disable MethodLength")
+          indent += '  '
+          obj.regs.each do |_reg_name, r|
+            reg_addr_offset = (r.address - obj.base_address).to_hex
+            reg_path = r.path.gsub(/#{klass}./i, '')
+            reg_path.chop! if reg_path[-1] == '.'
+            r.description.each do |line|
+              file.puts("#{indent}# #{line}")
+            end
+            reg_string = "#{indent}reg :#{r.name}, #{reg_addr_offset}, size: #{r.size}"
+            if r.respond_to? :bit_order
+              if r.bit_order.is_a?(String)
+                reg_string += ", bit_order: '#{r.bit_order}'"
+              elsif r.bit_order.is_a?(Symbol)
+                reg_string += ", bit_order: :#{r.bit_order}"
+              elsif r.bit_order.is_a?(NilClass)
+              # do not add bitorder if it is not available
+              else
+                reg_string += ", bit_order: #{r.bit_order}"
+              end
+            end
+            if r.respond_to? :space
+              if r.space.is_a?(String)
+                reg_string += ", space: '#{r.space}'"
+              elsif r.space.is_a?(Symbol)
+                reg_string += ", space: :#{r.space}"
+              else
+                reg_string += ", space: #{r.space}"
+              end
+            end
+            file.puts("#{reg_string} do |reg|")
+            indent += '  '
+            r.named_bits do |field, bits|
+              plain_bit_description = Nokogiri::HTML(bits.description.join(' ').to_s).text
+              plain_bit_description.gsub!(/"/, "'")
+              if bits.size > 1
+                bit_index = "#{bits.position + bits.size - 1}..#{bits.position}"
+              else
+                bit_index = bits.position.to_s
+              end
+              bits.description.each do |line|
+                file.puts("#{indent}# #{line}")
+              end
+              file.puts("#{indent}reg.bit #{bit_index}, :#{field}, reset: 0b#{bits.reset_val.to_s(2)}, access: :#{bits.access}")
+            end
+            indent = indent[0..-3]
+            file.puts("#{indent}end")
+          end
+          indent = indent[0..-3]
+          file.puts("#{indent}end")
+        end
+        @top_level_hierarchy.each do |_name, _obj|
+          indent = indent[0..-3]
+          file.puts("#{indent}end")
+        end
+        sub_hierarchy.each do |_name, _obj|
+          indent = indent[0..-3]
+          file.puts("#{indent}end")
+        end
+      end
+      # Place a '.' to the console to indicate file write progress to the user
+      print '.'
+      # If the current obj has sub_blocks then write those class files
+      if obj.respond_to?(:sub_blocks) && obj.send(:sub_blocks)
+        obj.sub_blocks.each do |_name, sb|
+          create_class_file(sb)
+        end
+      end
+    end
+
+    # Creates the class files for the sub_blocks instantiated in the BoM
+    def create_class_files
+      indent = ''
+      object_hierarchy = get_namespace(@obj)
+      klass = @obj.class.to_s.split('::').last
+      File.open(@incl_path, 'w') do |incl_file|
+        incl_file.chmod(0555)
+        incl_file.puts(FILE_COMMENTS[:incl])
+        @obj.sub_blocks.each do |_name, sb|
+          current_bist = nil
+          bypass_addr = 0
+          incl_file.puts("require_relative 'import/#{sb.name}.rb'")
+          File.open("#{@incl_dir}/#{sb.name}.rb", 'w') do |file|
+            file.chmod(0555)
+            file.puts('# -*- encoding : utf-8 -*-') if RUBY_VERSION < '2.0.0'
+            file.puts(FILE_COMMENTS[:class])
+            object_hierarchy.each do |name, obj|
+              file.puts("#{indent}#{obj} #{name.split('::').last}")
+              indent += '  '
+            end
+            file.puts("#{indent}class #{sb.name.upcase} # rubocop:disable ClassLength")
+            indent += '  '
+            file.puts("#{indent}include Origen::Model")
+            file.puts('')
+            SUB_BLOCK_ATTRS.each do |attr, comment|
+              attr_sym = ":#{attr}"
+              # First check that the attribute has content
+              if sb.respond_to?(attr)
+                next if sb.send(eval(attr_sym)).nil?
+                file.puts("#{indent}# #{comment}")
+                file.puts("#{indent}attr_reader :#{attr}")
+                file.puts('')
+              end
+            end
+            file.puts("#{indent}def initialize(options = {})")
+            indent += '  '
+            SUB_BLOCK_ATTRS.keys.each do |attr|
+              case attr
+                when /base_address/
+                  attr_var = ":@reg_#{attr}"
+                  file.puts("#{indent}\@#{attr} = #{sb.instance_variable_get(eval(attr_var)).to_hex}")
+                else
+                  attr_var = ":@#{attr}"
+                  attr_sym = ":#{attr}"
+                  # First check that the attribute has content
+                  if sb.respond_to?(attr)
+                    next if sb.send(eval(attr_sym)).nil?
+                    if sb.instance_variable_get(eval(attr_var)).is_a?(String)
+                      file.puts("#{indent}\@#{attr} = '#{sb.instance_variable_get(eval(attr_var))}'")
+                    elsif sb.instance_variable_get(eval(attr_var)).is_a?(Symbol)
+                      file.puts("#{indent}\@#{attr} = :#{sb.instance_variable_get(eval(attr_var))}")
+                    else
+                      file.puts("#{indent}\@#{attr} = #{sb.instance_variable_get(eval(attr_var))}")
+                    end
+                  end
+              end
+            end
+            file.puts("#{indent}instantiate_registers(options)")
+            indent = indent[0..-3]
+            file.puts("#{indent}end")
+            file.puts('')
+            file.puts("#{indent}# rubocop:disable LineLength")
+            # Need the register and bit_field descriptions to use double quotes
+            file.puts("#{indent}# rubocop:disable StringLiterals")
+            file.puts("#{indent}def instantiate_registers(options = {}) # rubocop:disable MethodLength")
+            indent += '  '
+            sb.regs.each do |_reg_name, r|
+              reg_addr_offset = (r.address - sb.base_address).to_hex
+              reg_path = r.path.gsub(/#{klass}./i, '')
+              reg_path.chop! if reg_path[-1] == '.'
+              r.description.each do |line|
+                file.puts("#{indent}# #{line}")
+              end
+              reg_string = "#{indent}reg :#{r.name}, #{reg_addr_offset}, size: #{r.size}"
+              if r.respond_to? :bit_order
+                if r.bit_order.is_a?(String)
+                  reg_string += ", bit_order: '#{r.bit_order}'"
+                elsif r.bit_order.is_a?(Symbol)
+                  reg_string += ", bit_order: :#{r.bit_order}"
+                elsif r.bit_order.is_a?(NilClass)
+                  # do not add bitorder if it is not available
+                else
+                  reg_string += ", bit_order: #{r.bit_order}"
+                end
+              end
+              if r.respond_to? :space
+                if r.space.is_a?(String)
+                  reg_string += ", space: '#{r.space}'"
+                elsif r.space.is_a?(Symbol)
+                  reg_string += ", space: :#{r.space}"
+                else
+                  reg_string += ", space: #{r.space}"
+                end
+              end
+              file.puts("#{reg_string} do |reg|")
+              indent += '  '
+              r.named_bits do |field, bits|
+                plain_bit_description = Nokogiri::HTML(bits.description.join(' ').to_s).text
+                plain_bit_description.gsub!(/"/, "'")
+                if bits.size > 1
+                  bit_index = "#{bits.position + bits.size - 1}..#{bits.position}"
+                else
+                  bit_index = bits.position.to_s
+                end
+                bits.description.each do |line|
+                  file.puts("#{indent}# #{line}")
+                end
+                file.puts("#{indent}reg.bit #{bit_index}, :#{field}, reset: 0b#{bits.reset_val.to_s(2)}, access: :#{bits.access}")
+              end
+              indent = indent[0..-3]
+              file.puts("#{indent}end")
+            end
+            indent = indent[0..-3]
+            file.puts("#{indent}end")
+            indent = indent[0..-3]
+            file.puts("#{indent}end")
+            object_hierarchy.each do |_name, _obj|
+              indent = indent[0..-3]
+              file.puts("#{indent}end")
+            end
+          end
+        end
+      end
+    end
+
+    # Returns a hash (key == scope, value is 'module' or 'class') needed to
+    # reconstruct the application hierarchy
+    def get_namespace(options)
+      obj = options[:obj]
+      namespace = []
+      object_hierarchy = {}
+      namespace =  obj.class.to_s.split('::')
+      namespace.pop if options[:class_name]
+      curr_eval = nil
+      scope = nil
+      namespace.each_with_index do |e, _i|
+        scope.nil? ? scope = e : scope += "::#{e}"
+        curr_eval = "#{scope}.class"
+        object_hierarchy["#{scope}"] = eval(curr_eval).to_s.downcase
+      end
+      if options[:class_name]
+        if object_hierarchy.empty?
+          object_hierarchy[options[:class_name]] = 'class'
+        else
+          object_hierarchy["#{object_hierarchy.keys.last}::#{options[:class_name]}"] = 'class'
+        end
+      end
+      object_hierarchy
+    end
+
+    # Returns a hash of all of the non-nil instance_variables for an instance
+    def instance_vars_with_content(obj)
+      ivars_content = {}
+      obj.instance_variables.each do |ivar|
+        ivar_sym = ivar.to_s.gsub('@', '').to_sym
+        # Check for reg_base_address as method base_address refers to this instance variable
+        # Could use reg_base_address but all docs show to use base_address in the sub_block calls
+        # If not reg_base_address the ivar must be included in SUB_BLOCK_ATTRS
+        next unless ivar_sym == :reg_base_address || SUB_BLOCK_ATTRS.include?(ivar_sym)
+        # Skip the instance variable if it is nil
+        next if obj.send(ivar_sym).nil?
+        if ivar_sym == :reg_base_address
+          ivars_content[:base_address] = obj.send(ivar_sym)
+        else
+          ivars_content[ivar_sym] = obj.send(ivar_sym)
+        end
+      end
+      ivars_content
+    end
+
+    # Recursively work through the object hierarchy and return the full class string
+    def get_full_class(obj)
+      class_str = ''
+      until obj.nil?
+        if obj == Origen.top_level
+          class_str.prepend @top_level_hierarchy.keys.last
+        else
+          # If the class method produces "SubBlock" then use the object name instead
+          if obj.class.to_s.split('::').last == 'SubBlock'
+            class_str.prepend "::#{obj.name.upcase}"
+          else
+            class_str.prepend "::#{obj.class.to_s.split('::').last}"
+          end
+        end
+        obj = obj.parent
+      end
+      class_str
+    end
+  end
+end

data/lib/cross_origen/ralf.rb

@@ -0,0 +1,15 @@
+module CrossOrigen
+  class Ralf
+    # Returns the object that included the CrossOrigen module
+    attr_reader :owner
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    # Returns a string representing the owner object in RALF format
+    def owner_to_ralf(options = {})
+      Origen.compile("#{Origen.root!}/templates/ralf/default.ralf.erb", options.merge(scope: owner))
+    end
+  end
+end

data/lib/cross_origen/test/dut.rb

@@ -0,0 +1,51 @@
+module CrossOrigen
+  module Test
+    # Simple DUT class used for testing
+    class DUT
+      include Origen::TopLevel
+      include CrossOrigen
+
+      def initialize
+        @path = :hidden
+        sub_block :atx, class_name: 'D_IP_ANA_TEST_ANNEX_SYN'
+
+        # Register defined solely to test out the top level register export
+        reg :dut_top_level_reg, 0x0, size: 32, bit_order: :msb0, lau: 8 do
+          bit 15, :pls_work, reset: 1, access: :rw
+          bit 14, :second_bit, reset: 0, access: :rw
+        end
+        # Register defined solely to test out the top level register export
+        reg :dut_top_level_reg_number_two, 0x10, size: 32, bit_order: :lsb0, lau: 16 do
+          bit 0, :pls_work, reset: 0, access: :ro
+          bit 1, :second_bit, reset: 1, access: :rw
+        end
+        # Import some data from IP-XACT
+        cr_import(path: "#{Origen.root}/imports/ipxact.xml")
+      end
+
+      class D_IP_ANA_TEST_ANNEX_SYN # rubocop:disable ClassAndModuleCamelCase
+        include Origen::Model
+        include CrossOrigen
+
+        def initialize
+          # A manually defined register for testing the conversion of any specific attributes
+
+          # ** MGATE Clock Divider Register **
+          # The MCLKDIV register is used to divide down the frequency of the HBOSCCLK input. If the MCLKDIV
+          # register is set to value "N", then the output (beat) frequency of the clock divider is OSCCLK / (N+1). The
+          # resulting beats are, in turn, counted by the PTIMER module to control the duration of Flash high-voltage
+          # operations.
+          # This is a test of potentially problematic characters ' " \' \" < >
+          reg :mclkdiv, 0x0, size: 16, bit_order: 'decrement' do
+            # **Oscillator (Hi)** - Firmware FMU clk source selection. (Note that in addition to this firmware-controlled bit, the
+            # FMU clock source is also dependent on test and power control discretes).
+            #
+            # 0 | FMU clock is the externally supplied bus clock ipg_clk
+            # 1 | FMU clock is the internal oscillator from the TFS hardblock
+            bit 15, :osch, reset: 1, access: :rw
+          end
+        end
+      end
+    end
+  end
+end