cross_origen 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a8a97d56c4be0c17d49a9486ec425b34eab92fc
-  data.tar.gz: 19f08b7708edb0fd9b1b1da7bd2b7a0e59b98766
+  metadata.gz: 2d26f7c82e096e575a790df75455dfbf852566b2
+  data.tar.gz: 20b0f23e1252fbf6775945ad77a61ae9da871938
 SHA512:
-  metadata.gz: de17ae91904278a13727d3ae7d2e1d3f48e1e45a29177e31155a6281a0d3623b17eaf33e7aabb9d13f553f337a37a205d9c00a02c4c12e2bae378f26a0ce9025
-  data.tar.gz: e20b7196527a69f0bedacbe778843beb1dde1da11495405d820cb9a89d106c3f787f3e1e61d184106dc05e9bfbc54ee1aa293269a6a62a87d45307b359a30515
+  metadata.gz: 9735b99514ec7b4c0ba88af969195cc9323d2967636a6c4bc98b414bd7ebd2bd24afd84686c64df04b7cd11ff437f39258928a145a101126579ac7df5de99c24
+  data.tar.gz: a8bfaad922bf7fcaab7bb2b3f9ab526d2b63a775f3f75087f6052b8e0efc3a5788d2bd492ed5ebd8b238ab06e75f0d345ff5ea562cdb33db28e3c277f4d3ad2d

data/bin/fix_my_workspace

@@ -2,9 +2,17 @@
 $VERBOSE = nil  # Don't care about world writable dir warnings and the like
 
 if $_fix_my_workspace_version_check
-  $_fix_my_workspace_version = '0.6.0'
+  $_fix_my_workspace_version = '0.7.0'
 else
-  require 'origen'
+  if File.exist?(File.expand_path('../../lib/origen.rb', __FILE__))
+    # If this script is being run from within an origen-core workspace, use that Origen-core,
+    # not the system-installed origen-core version.
+    $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+    require 'origen'
+  else
+    # Use system-installed Origen (the gem in system Ruby)
+    require 'origen'
+  end
 
   if !Origen.site_config.gem_manage_bundler
     puts 'Sorry but you have opted to manage Bundler yourself via your Origen site config, and this means'

data/config/{development.rb → boot.rb}

@@ -10,8 +10,4 @@
 # this would be used to load some dummy classes to instantiate
 # your objects so that they can be tested and/or interacted with
 # in the console.
-module CrossOrigen
-  module Test
-    autoload :DUT, "cross_origen/test/dut"
-  end
-end
+require "cross_origen_dev/dut"

data/config/shared_commands.rb

@@ -1,18 +1,22 @@
+if ARGV.delete('--refresh') || ARGV.delete('-refresh')
+  CrossOrigen.instance_variable_set('@refresh', true)
+end
+
 # The requested command is passed in here as @command
 case @command
 
 when "cr:import"
-  require "cross_origen/commands/import"
-  # Important to exit when a command has been fulfilled or else Origen core will try and execute it
-  exit 0
+#  require "cross_origen/commands/import"
+#  # Important to exit when a command has been fulfilled or else Origen core will try and execute it
+#  exit 0
 
 # Always leave an else clause to allow control to fall back through to the Origen command handler.
 # You probably want to also add the command details to the help shown via 'origen -h',
 # you can do this bb adding the required text to @plugin_commands before handing control back to
 # Origen.
 else
-  @plugin_commands << <<-EOT
- cr:import       Import peripheral and register data from 3rd party formats
-  EOT
+#  @plugin_commands << <<-EOT
+# cr:import       Import peripheral and register data from 3rd party formats
+#  EOT
 
 end

data/config/version.rb

@@ -1,6 +1,6 @@
 module CrossOrigen
-  MAJOR = 0
-  MINOR = 7
+  MAJOR = 1
+  MINOR = 0
   BUGFIX = 0
   DEV = nil
 

data/lib/cross_origen/cmsis_svd.rb

@@ -1,143 +1,155 @@
 module CrossOrigen
   class CMSISSVD < XMLDoc
     def import(file, options = {}) # rubocop:disable CyclomaticComplexity
-      with_output_file(options) do |f|
-        doc(file, options) do |doc|
-          f.puts '# This file was automatically generated from a CMSIS-SVD input file'
-          f.puts '# Name:    ' + (fetch(doc.xpath('device/name'), get_text: true) || '')
-          f.puts '# Version: ' + (fetch(doc.xpath('device/version'), get_text: true) || '')
-          f.puts "# Created at #{Time.now.strftime('%e %b %Y %H:%M%p')} by #{User.current.name}"
-          f.puts '# rubocop:disable all'
-          f.puts 'module ImportedCMSISSVD'
-          f.puts '  def initialize(*args)'
-          f.puts '    instantiate_imported_cmsis_svd_data'
-          f.puts '  end'
-          f.puts ''
-          f.puts '  def instantiate_imported_cmsis_svd_data'
-
-          # Create sub-blocks
-          indexes = {}
-          doc.xpath('device/peripherals/peripheral').each do |p|
-            name = fetch(p.xpath('groupName'), get_text: true)
-            name = name.to_s.downcase.symbolize
-            ba = extract(p, 'baseAddress', format: :integer, hex: true)
-            if j = peripheral_groups(doc)[name] > 1
-              indexes[name] ||= 0
-              f.puts "    sub_block :#{name}#{indexes[name]}, base_address: #{ba.to_hex}"
-              indexes[name] += 1
-            else
-              f.puts "    sub_block :#{name}, base_address: #{ba.to_hex}"
-            end
+      filename = Pathname.new(file).basename('.*').to_s
+
+      unless options[:refresh] || CrossOrigen.refresh?
+        return if owner.import(filename, allow_missing: true)
+      end
+
+      model = CrossOrigen::Model.new
+
+      doc(file, options) do |doc|
+        peripherals = peripherals(doc)
+        groups = peripherals.values.map { |v| v[:group] }.uniq
+
+        groups.each { |group| model.sub_block group }
+
+        peripherals.each do |name, attrs|
+          base = attrs[:group] ? model.send(attrs[:group]) : model
+          block = base.sub_block name, base_address: attrs[:base_address]
+
+          if attrs[:parent]
+            add_registers(block, find_peripheral_by_name(doc, attrs[:parent]))
           end
-          f.puts ''
-
-          # Add registers to each sub-block
-          indexes = {}
-          doc.xpath('device/peripherals/peripheral').each do |p|
-            sb = fetch(p.xpath('groupName'), get_text: true)
-            sb = sb.to_s.downcase.symbolize
-            if j = peripheral_groups(doc)[sb] > 1
-              indexes[sb] ||= 0
-              ix = indexes[sb]
-              indexes[sb] += 1
-              sb = "#{sb}#{ix}"
-            end
+          add_registers(block, find_peripheral_by_name(doc, name))
+        end
+      end
+      model.export(filename, include_timestamp: CrossOrigen.include_timestamp?)
+      owner.import(filename)
+    end
 
-            p.xpath('registers/register').each do |r|
-              name = extract(r, 'name')
-              di = extract(r, 'dim', format: :integer)
-              dim = !!di
-              if dim
-                dinc = extract(r, 'dimIncrement', format: :integer)
-                dvals = extract(r, 'dimIndex').split(',')
-              else
-                di = 1
-              end
-              offset = extract(r, 'addressOffset', format: :integer, hex: true)
-              size = extract(r, 'size', format: :integer)
-              reset = extract(r, 'resetValue', format: :integer, hex: true)
-              desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
-
-              di.times do |i|
-                if dim
-                  n = name.sub('[%s]', dvals[i])
-                  addr = offset + (i * dinc)
-                else
-                  n = name
-                  addr = offset
-                end
-                f.puts "    #{sb}.add_reg :#{n.downcase.symbolize}, #{addr.to_hex}, size: #{size}#{reset ? ', reset: ' + reset.to_hex : ''}, description: '#{desc}' do |reg|"
-                r.xpath('fields/field').each do |b|
-                  bn = extract(b, 'name')
-                  unless bn == 'RESERVED'
-                    bn = bn.to_s.downcase.symbolize
-                    lsb = extract(b, 'lsb', format: :integer)
-                    msb = extract(b, 'msb', format: :integer)
-                    access = extract(b, 'access')
-                    desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
-                    case access
-                    when 'read-only'
-                      ac = :ro
-                    else
-                      ac = :rw
-                    end
-                    if lsb == msb
-                      f.puts "      reg.bit #{lsb}, :#{bn}, access: :#{ac}, description: '#{desc}'"
-                    else
-                      f.puts "      reg.bit #{msb}..#{lsb}, :#{bn}, access: :#{ac}, description: '#{desc}'"
-                    end
+    private
+
+    def add_registers(model, peripheral)
+      peripheral.xpath('registers/register').each do |r|
+        name = extract(r, 'name')
+        di = extract(r, 'dim', format: :integer)
+        dim = !!di
+        if dim
+          dinc = extract(r, 'dimIncrement', format: :integer)
+          dvals = extract(r, 'dimIndex').split(',')
+        else
+          di = 1
+        end
+        offset = extract(r, 'addressOffset', format: :integer, hex: true)
+        size = extract(r, 'size', format: :integer)
+        reset = extract(r, 'resetValue', format: :integer, hex: true)
+        desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
+
+        di.times do |i|
+          if dim
+            n = name.sub('[%s]', dvals[i])
+            addr = offset + (i * dinc)
+          else
+            n = name
+            addr = offset
+          end
+          opts = {
+            size:        size,
+            description: desc
+          }
+          opts[:reset] = reset if reset
+          reg_name = n.downcase.symbolize
+          # The register could already exist if it was added by a parent peripheral definition and now it
+          # is redefined/overridden by a descendent peripheral
+          model.del_reg(reg_name) if model.has_reg?(reg_name)
+          model.reg reg_name, addr, opts do |reg|
+            r.xpath('fields/field').each do |b|
+              bn = extract(b, 'name')
+              unless bn == 'RESERVED'
+                bn = bn.to_s.downcase.symbolize
+                lsb = extract(b, 'lsb', format: :integer)
+                msb = extract(b, 'msb', format: :integer)
+                unless lsb
+                  lsb = extract(b, 'bitOffset', format: :integer)
+                  if lsb
+                    msb = lsb + extract(b, 'msb', format: :integer) - 1
                   end
                 end
-                f.puts '    end'
-              end
-            end
-          end
-
-          f.puts '  end'
-
-          # Create accessor methods to return an array of peripherals in the case
-          # where there are many in a group
-          peripheral_groups(doc).each do |name, size|
-            name = name.to_s.downcase.symbolize
-            if size > 1
-              f.puts ''
-              f.puts "  def #{name}"
-              f.print '    ['
-              size.times do |i|
-                if i == 0
-                  f.print "#{name}0"
+                unless lsb
+                  range = extract(b, 'bitRange')
+                  range =~ /\[(\d+):(\d+)\]/
+                  lsb = Regexp.last_match(2).to_i
+                  msb = Regexp.last_match(1).to_i
+                end
+                access = extract(b, 'access')
+                desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
+                case access
+                when 'read-only'
+                  ac = :ro
+                else
+                  ac = :rw
+                end
+                if lsb == msb
+                  reg.bit lsb, bn, access: ac, description: desc
                 else
-                  f.print ", #{name}#{i}"
+                  reg.bit msb..lsb, bn, access: ac, description: desc
                 end
               end
-              f.puts ']'
-              f.puts '  end'
             end
           end
-
-          f.puts 'end'
-          f.puts '# rubocop:enable all'
         end
       end
     end
 
-    def peripheral_groups(doc)
-      @peripheral_groups ||= begin
-        g = {}
-        doc.xpath('device/peripherals/peripheral').each do |p|
-          group = fetch(p.xpath('groupName'), get_text: true)
-          group = group.to_s.downcase.symbolize
-          g[group] ||= 0
-          g[group] += 1
-        end
-        g
+    def find_peripheral_by_name(doc, pname)
+      doc.xpath('device/peripherals/peripheral').find do |peripheral|
+        pname == name(peripheral)
+      end
+    end
+
+    def clean_name(name)
+      name = name.to_s
+      unless name.empty?
+        name.downcase.symbolize
       end
     end
 
-    def with_output_file(options = {})
-      path = options[:output] || 'imported_cmsis_svd.rb'
-      File.open(path, 'w') { |f| yield f }
-      puts "Successfully imported to #{path}"
+    def name(peripheral)
+      clean_name(fetch(peripheral.xpath('name'), get_text: true))
+    end
+
+    def group_name(peripheral)
+      clean_name(fetch(peripheral.xpath('groupName'), get_text: true))
+    end
+
+    def parent(peripheral)
+      a = peripheral.attributes['derivedFrom']
+      a ? clean_name(a.value) : nil
+    end
+
+    def base_address(peripheral)
+      extract(peripheral, 'baseAddress', format: :integer, hex: true)
+    end
+
+    def peripherals(doc)
+      peripherals = {}
+      doc.xpath('device/peripherals/peripheral').each do |peripheral|
+        peripherals[name(peripheral)] = {
+          group:        group_name(peripheral),
+          parent:       parent(peripheral),
+          base_address: base_address(peripheral)
+        }
+      end
+      # Inherit missing values from parents...
+      p = {}
+      peripherals.each do |k, v|
+        v[:group] ||= peripherals[v[:parent]][:group]
+        v[:base_address] ||= peripherals[v[:parent]][:base_address]
+        p[k] = v
+      end
+      p
     end
   end
 end

data/lib/cross_origen/ip_xact.rb

@@ -10,6 +10,14 @@ module CrossOrigen
     def import(file, options = {}) # rubocop:disable CyclomaticComplexity
       require 'kramdown'
 
+      filename = Pathname.new(file).basename('.*').to_s
+
+      unless options[:refresh] || CrossOrigen.refresh?
+        return if owner.import(filename, allow_missing: true)
+      end
+
+      model = CrossOrigen::Model.new
+
       address_spaces = {}
 
       doc(file, options) do |doc|
@@ -19,15 +27,21 @@ module CrossOrigen
           width = fetch addr_space.at_xpath('spirit:width'), get_text: true, to_i: true
           address_spaces[name] = AddressSpace.new(name, range, width)
         end
-        doc.xpath('//spirit:memoryMaps/spirit:memoryMap').each do |mem_map|
-          mem_map_name = fetch mem_map.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
-          if mem_map_name.to_s.empty?
-            mem_map_obj = owner
+        open_memory_map(doc) do |mem_map|
+          if mem_map
+            mem_map_name = fetch mem_map.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
+            if mem_map_name.to_s.empty?
+              mem_map_obj = model
+            else
+              model.sub_block mem_map_name
+              mem_map_obj = model.send(mem_map_name)
+            end
+            addr_blocks = mem_map.xpath('spirit:addressBlock')
           else
-            owner.sub_block mem_map_name
-            mem_map_obj = owner.send(mem_map_name)
+            mem_map_obj = model
+            addr_blocks = doc.xpath('//spirit:addressBlock')
           end
-          mem_map.xpath('spirit:addressBlock').each do |addr_block|
+          addr_blocks.each do |addr_block|
             name = fetch addr_block.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
             base_address = fetch addr_block.at_xpath('spirit:baseAddress'), get_text: true, to_dec: true
             range = fetch addr_block.at_xpath('spirit:range'), get_text: true, to_dec: true
@@ -78,6 +92,28 @@ module CrossOrigen
           end
         end
       end
+      model.export(filename, include_timestamp: CrossOrigen.include_timestamp?)
+      owner.import(filename)
+    end
+
+    def doc(path, options = {})
+      # If a fragment of IP-XACT is given, then wrap it with a valid header and we will try our best
+      if options[:fragment]
+        require 'nokogiri'
+
+        content = %(
+<?xml version="1.0"?>
+<spirit:component xmlns:spirit="http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4"
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="$REGMEM_HOME/builder/ipxact/schema/ipxact
+          $REGMEM_HOME/builder/ipxact/schema/ipxact/index.xsd">
+        #{File.read(path)}
+</spirit:component>
+        )
+        yield Nokogiri::XML(content)
+      else
+        super
+      end
     end
 
     # Returns a string representing the owner object in IP-XACT XML
@@ -191,6 +227,14 @@ module CrossOrigen
 
     private
 
+    def open_memory_map(doc)
+      maps = doc.xpath('//spirit:memoryMaps/spirit:memoryMap')
+      maps = [nil] if maps.empty?
+      maps.each do |mem_map|
+        yield mem_map
+      end
+    end
+
     def reg_description(register)
       fetch register.at_xpath('spirit:description'), get_text: true, whitespace: true
     end

data/lib/cross_origen/xml_doc.rb

@@ -83,7 +83,7 @@ module CrossOrigen
     end
 
     # This returns the doc wrapped by a Nokogiri doc
-    def doc(path, _options = {})
+    def doc(path, options = {})
       require 'nokogiri'
 
       File.open(path) do |f|

data/lib/cross_origen.rb

@@ -1,15 +1,31 @@
 require 'origen'
 require_relative '../config/application.rb'
-require_relative '../config/environment.rb'
 
 module CrossOrigen
-  if RUBY_VERSION < '2.0.0'
-    require 'scrub_rb'
+  autoload :XMLDoc,       'cross_origen/xml_doc'
+  autoload :Headers,      'cross_origen/headers'
+  autoload :Ralf,         'cross_origen/ralf'
+  autoload :IpXact,       'cross_origen/ip_xact'
+  autoload :DesignSync,   'cross_origen/design_sync'
+  autoload :CMSISSVD,     'cross_origen/cmsis_svd'
+
+  # Basic object that is used to capture imported data and then export/save
+  # it to Origen format
+  class Model
+    include Origen::Model
   end
-  extend ActiveSupport::Concern
 
-  included do
-    include Origen::Model
+  # Returns true if the --refresh switch was passed to the current Origen command
+  def self.refresh?
+    @refresh || false
+  end
+
+  def self.include_timestamp?
+    instance_variable_defined?(:@include_timestamp) ? @include_timestamp : true
+  end
+
+  def self.include_timestamp=(val)
+    @include_timestamp = val
   end
 
   def instance_respond_to?(method_name)
@@ -17,6 +33,10 @@ module CrossOrigen
   end
 
   def cr_import(options = {})
+    options = {
+      include_timestamp: true
+    }.merge(options)
+    CrossOrigen.include_timestamp = options[:include_timestamp]
     file = cr_file(options)
     cr_translator(file, options).import(file, options)
   end
@@ -30,11 +50,6 @@ module CrossOrigen
   end
   alias_method :to_ipxact, :to_ip_xact
 
-  def to_origen(options = {})
-    options[:obj] = self
-    cr_to_origen(options)
-  end
-
   def to_header(options = {})
     cr_headers.owner_to_header(options)
   end
@@ -60,21 +75,6 @@ module CrossOrigen
     @cr_headers ||= Headers.new(self)
   end
 
-  # Creates Ruby files necessary to model all sub_blocks and registers found (recursively) owned by options[:obj]
-  # The Ruby files are created at options[:path] (app output directory by default)
-  def cr_to_origen(options = {})
-    options = {
-      obj:               $dut,
-      path:              Origen.app.config.output_directory,
-      instantiate_level: :top
-    }.update(options)
-    # This method assumes and checks for $self to contain Origen::Model
-    error "ERROR: #{options[:obj].class} does not contain Origen::Model as required" unless options[:obj].class < Origen::Model
-    # Check to make sure there are sub_blocks or regs directly under $dut
-    error "ERROR: options[:obj]ect #{options[:obj].object_id} of class #{options[:obj].class} does not contain registers or sub_blocks" unless options[:obj].owns_registers? || options[:obj].instance_respond_to?(:sub_blocks)
-    OrigenFormat.new(options).export
-  end
-
   def cr_ralf
     @cr_ralf ||= Ralf.new(self)
   end
@@ -83,16 +83,28 @@ module CrossOrigen
     @cr_ip_xact ||= IpXact.new(self)
   end
 
+  def cr_cmsis_svd
+    @cr_cmsis_svd ||= CMSISSVD.new(self)
+  end
+
   private
 
   # Returns an instance of the translator for the format of the given file
-  def cr_translator(file, _options = {})
+  def cr_translator(file, options = {})
     snippet = IO.read(file, 2000)  # Read first 2000 characters
     case snippet
     when /spiritconsortium/
       cr_ip_xact
+    when /CMSIS-SVD.xsd/
+      cr_cmsis_svd
     else
-      fail "Unknown file format for file: #{file}"
+      # Give IP-XACT another opportunity if it looks like partial IP-XACT doc
+      if snippet =~ /<spirit:register>/
+        options[:fragment] = true
+        cr_ip_xact
+      else
+        fail "Unknown file format for file: #{file}"
+      end
     end
   end
 

data/lib/cross_origen_dev/dut.rb

@@ -0,0 +1,62 @@
+module CrossOrigenDev
+  # 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', base_address: 0x4000_0000
+
+      # 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
+
+    def add_atx2
+      sub_block :atx2, class_name: 'ATX2', base_address: 0x6000_0000
+    end
+
+    class ATX2
+      include Origen::Model
+      include CrossOrigen
+
+      def initialize
+        cr_import(path: "#{Origen.root}/approved/ip_xact_sub_block.xml")
+      end
+    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