cross_origen 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 20fb4952ec7d0da9dcad3673c0442cbc1b79afc3
+  data.tar.gz: 8b55d120f0783322f057ba2db4fc638d063f1443
+SHA512:
+  metadata.gz: 513b242817d94cd5b7f7614ca14087150e9e5cbcad31995e9eea344493d35bf525a6b9d52a268702b0d3ec73b44f31338d0d755e80b30fbcfec1d6a4183fe038
+  data.tar.gz: 9b767385a47a1f14319b4c22e4feb4c575f4aef07f615a70f376f12998623921642eff97e9b8dc9940b4248a7074b78923c81ebf76fc64dde058bc5c3cd1cc7e

data/config/application.rb

@@ -0,0 +1,78 @@
+class CrossOrigenApplication < Origen::Application
+
+  # See http://origen.freescale.net/origen/latest/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    :run_on_tag => true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    :auto_correct => true, 
+    # Limit the testing for large legacy applications
+    #:level => :easy,
+    # Run on these directories/files by default
+    #:files => ["lib", "config/application.rb"],
+  }
+
+  # Prevent these from showing up in 'origen rc unman'
+  config.unmanaged_dirs = %w()
+  config.unmanaged_files = %w()
+
+  # This information is used in headers and email templates, set it specific
+  # to your application
+  config.name     = "Cross Origen"
+  config.initials = "CrossOrigen"
+  config.rc_url   = "git@github.com:Origen-SDK/cross_origen.git"
+  config.release_externally = true
+
+  config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/cross_origen"
+  config.web_domain = "http://origen-sdk.org/cross_origen"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  config.semantically_version = true
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory. 
+  #config.output_directory do
+  #  "#{Origen.root}/output/#{$dut.class}"
+  #end
+
+  # Similary for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  #config.reference_directory do
+  #  "#{Origen.root}/.ref/#{$dut.class}"
+  #end
+
+  # Ensure that all tests pass before allowing a release to continue
+  def validate_release
+    if !system("origen test")
+      puts "Sorry but you can't release with failing tests, please fix them and try again."
+      exit 1
+    else
+      puts "All tests passing, proceeding with the release process!"
+    end
+  end
+
+  # Run the tests before deploying to generate test coverage numbers
+  def before_deploy_site
+    Dir.chdir Origen.root do
+      system "origen test -c"
+      dir = "#{Origen.root}/web/output/coverage"       
+      FileUtils.remove_dir(dir, true) if File.exists?(dir) 
+      system "mv #{Origen.root}/coverage #{dir}"
+    end
+  end
+ 
+  # This will automatically deploy your documentation after every tag
+  def after_release_email(tag, note, type, selector, options)
+    command = "origen web compile --remote --api"
+    Dir.chdir Origen.root do
+      system command
+    end
+  end
+end

data/config/commands.rb

@@ -0,0 +1,47 @@
+# This file should be used to extend origen with application specific tasks
+
+aliases ={
+
+}
+
+@command = aliases[@command] || @command
+
+case @command
+
+when "specs"
+  require "rspec"
+  exit RSpec::Core::Runner.run(['spec'])
+
+when "examples", "test"  
+  status = 0
+
+  ARGV = %w(templates/test -t debug -r approved)
+  load "origen/commands/compile.rb"
+  
+  if Origen.app.stats.changed_files == 0 &&
+     Origen.app.stats.new_files == 0 &&
+     Origen.app.stats.changed_patterns == 0 &&
+     Origen.app.stats.new_patterns == 0
+
+    Origen.app.stats.report_pass
+  else
+    Origen.app.stats.report_fail
+    status = 1
+  end
+  puts
+  if @command == "test"
+    Origen.app.unload_target!
+    require "rspec"
+    result = RSpec::Core::Runner.run(['spec'])
+    status = status == 1 ? 1 : result
+  end
+  exit status
+
+else
+  @application_commands = <<-EOT
+ specs        Run the specs (unit tests), -c will enable coverage
+ examples     Run the examples (acceptance tests), -c will enable coverage
+ test         Run both specs and examples, -c will enable coverage
+  EOT
+
+end

data/config/development.rb

@@ -0,0 +1,17 @@
+# This file is similar to environment.rb and will be loaded
+# automatically at the start of each invocation of Origen.
+#
+# However the major difference is that it will not be loaded
+# if the application is imported by a 3rd party app - in that
+# case only environment.rb is loaded.
+#
+# Therefore this file should be used to load anything you need
+# to setup a development environment for this app, normally
+# 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

data/config/environment.rb

@@ -0,0 +1,35 @@
+# This file will be required by Origen before your target is loaded, you
+# can use this to require all of your files, which is the easiest way
+# to get started. As your experience grows you may wish to require only the
+# minimum files required to allow the target to be initialized and let
+# each class require its own dependencies.
+#
+# It is recommended that you keep all of your application logic in lib/
+# The lib directory has already been added to the search path and so any files
+# in there can be referenced from here with a relative path.
+#
+# Note that pattern files do not need to be referenced from here and these
+# will be located automatically by origen.
+
+# This says load the file "lib/pioneer.rb" the first time anyone makes a
+# reference to the class name 'Pioneer'.
+#autoload :Pioneer,   "pioneer"
+# This is generally preferable to using require which will load the file
+# regardless of whether it is needed by the current target or not:
+#require "pioneer"
+# Sometimes you have to use require however:-
+#   1. When defining a test program interface:
+#require "interfaces/j750"
+#   2. If you want to extend a class defined by an imported application, in
+#      this case your must use required and supply a full path (to distinguish
+#      it from the one in the parent application):
+#require "#{Origen.root}/c90_top_level/p2"
+module CrossOrigen
+  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 :OrigenFormat, "cross_origen/origen_format"
+end
+require "cross_origen"

data/config/users.rb

@@ -0,0 +1,18 @@
+# This file defines the users associated with your project, it is basically the 
+# mailing list for release notes.
+#
+# You can split your users into "admin" and "user" groups, the main difference 
+# between the two is that admin users will get all tag emails, users will get
+# emails on external/official releases only.
+#
+# Users are also prohibited from running the "origen tag" task, but this is 
+# really just to prevent a casual user from executing it inadvertently and is
+# not intended to be a serious security gate.
+module Origen
+  module Users
+    def users
+      @users ||= [
+      ]
+    end
+  end
+end

data/config/version.rb

@@ -0,0 +1,8 @@
+module CrossOrigen
+  MAJOR = 0
+  MINOR = 5
+  BUGFIX = 0
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/cross_origen/design_sync.rb

@@ -0,0 +1,54 @@
+module CrossOrigen
+  # Driver for talking to DesignSync
+  class DesignSync
+    require 'digest/sha1'
+
+    # Returns the object that included the CrossOrigen module
+    attr_reader :owner
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def driver
+      @driver ||= Origen::Utility::DesignSync.new
+    end
+
+    # Returns a full path to the Design Sync import (cache) directory
+    def import_dir
+      return @import_dir if @import_dir
+      @import_dir = "#{Origen.app.workspace_manager.imports_directory}/design_sync"
+      FileUtils.mkdir_p(@import_dir) unless File.exist?(@import_dir)
+      @import_dir
+    end
+
+    # This will be called if the user has supplied a :vault in the rs_import options. The corresponding
+    # version of the file will be returned from the cache if it already exists locally, otherwise it
+    # will be imported.
+    #
+    # This method returns a full path to the local cache copy of the file.
+    def fetch(options = {})
+      unless options[:version]
+        puts 'You must supply a :version number (or tag) when importing data from Design Sync'
+        exit 1
+      end
+      v = options[:vault]
+      f = v.split('/').last
+      vault = v.sub(/\/#{f}$/, '')
+      # Consider that similarly named files could exist in different vaults, so attach
+      # a representation of the vault to the filename
+      vault_hash = Digest::SHA1.hexdigest(vault)
+      dir = "#{import_dir}/#{vault_hash}-#{f}"
+      file = "#{dir}/#{options[:version]}"
+      if f =~ /.*\.(.*)/
+        file += ".#{Regexp.last_match[1]}"
+      end
+      if !File.exist?(file) || options[:force]
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+        driver.import(f, vault, options[:version], dir)
+        FileUtils.mv("#{dir}/#{f}", file)
+      end
+      file
+    end
+  end
+end

data/lib/cross_origen/headers.rb

@@ -0,0 +1,21 @@
+module CrossOrigen
+  class Headers
+    # Returns the object that included the CrossOrigen module
+    attr_reader :owner
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    # Returns a string representing the owner as a C header
+    def owner_to_header(_options = {})
+      Origen.compile("#{path_to_templates}/headers/default.h.erb", scope: owner)
+    end
+
+    private
+
+    def path_to_templates
+      "#{File.expand_path(File.dirname(__FILE__))}/../../templates"
+    end
+  end
+end

data/lib/cross_origen/ip_xact.rb

@@ -0,0 +1,243 @@
+module CrossOrigen
+  class IpXact < XMLDoc
+    AddressSpace = Struct.new(:name, :range, :width)
+
+    MemoryMaps = Struct.new(:name, :address_blocks)
+
+    AddressBlock = Struct.new(:name, :base_address, :range, :width)
+
+    # Import/reader that currently only supports creating registers and bit fields
+    def import(file, options = {}) # rubocop:disable CyclomaticComplexity
+      require 'kramdown'
+
+      address_spaces = {}
+
+      doc(file, options) do |doc|
+        doc.xpath('//spirit:addressSpaces/spirit:addressSpace').each do |addr_space|
+          name = fetch addr_space.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
+          range = fetch addr_space.at_xpath('spirit:range'), get_text: true, to_dec: true
+          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
+          owner.sub_block mem_map_name
+          mem_map_obj = owner.send(mem_map_name)
+          mem_map.xpath('spirit:addressBlock').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
+            width = fetch addr_block.at_xpath('spirit:width'), get_text: true, to_i: true
+            mem_map_obj.sub_block name, base_address: base_address, range: range, lau: width
+            addr_block_obj = mem_map_obj.send(name)
+            addr_block.xpath('spirit:register').each do |register|
+              name = fetch register.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
+              size = fetch register.at_xpath('spirit:size'), get_text: true, to_i: true
+              addr_offset = fetch register.at_xpath('spirit:addressOffset'), get_text: true, to_dec: true
+              access = fetch register.at_xpath('spirit:access'), get_text: true
+              reset_value = fetch register.at_xpath('spirit:reset/spirit:value'), get_text: true, to_dec: true
+              reset_mask = fetch register.at_xpath('spirit:reset/spirit:mask'), get_text: true, to_dec: true
+              if [reset_value, reset_mask].include? nil
+                # Set default values for some register attributes
+                reset_value, reset_mask = 0, 0
+              else
+                # Do a logical bitwise AND with the reset value and mask
+                reset_value = reset_value & reset_mask
+              end
+              addr_block_obj.reg name, addr_offset, size: size, access: access do |reg|
+                register.xpath('spirit:field').each do |field|
+                  name = fetch field.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
+                  bit_offset = fetch field.at_xpath('spirit:bitOffset'), get_text: true, to_i: true
+                  bit_width = fetch field.at_xpath('spirit:bitWidth'), get_text: true, to_i: true
+                  access = fetch field.at_xpath('spirit:access'), get_text: true
+                  if access =~ /\S+\-\S+/
+                    access = access[/^(\S)/, 1] + access[/\-(\S)\S+$/, 1]
+                    access = access.downcase.to_sym
+                  else
+                    # default to read-write if access is not specified
+                    access = :rw
+                  end
+                  range = nil
+                  if bit_width == 1
+                    range = bit_offset
+                  else
+                    range = (bit_offset + bit_width - 1)..bit_offset
+                  end
+                  reg.bit range, name, reset: reset_value[range], access: access
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Returns a string representing the owner object in IP-XACT XML
+    def owner_to_xml(options = {})
+      require 'builder'
+
+      options = {
+        include_bit_field_values: true
+      }.merge(options)
+
+      @format = options[:format]
+
+      xml = Builder::XmlMarkup.new(indent: 2, margin: 0)
+
+      xml.instruct!
+
+      schemas = [
+        'http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4',
+        'http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4/index.xsd'
+      ]
+      if uvm?
+        schemas << '$IREG_GEN/XMLSchema/SPIRIT/VendorExtensions.xsd'
+      end
+
+      headers = {
+        'xmlns:spirit'       => 'http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4',
+        'xmlns:xsi'          => 'http://www.w3.org/2001/XMLSchema-instance',
+        'xsi:schemaLocation' => schemas.join(' ')
+      }
+      if uvm?
+        headers['xmlns:vendorExtensions'] = '$IREG_GEN/XMLSchema/SPIRIT'
+      end
+
+      xml.tag!('spirit:component', headers) do
+        xml.spirit :vendor, options[:vendor] || 'Freescale'
+        xml.spirit :library, options[:library] || 'Freescale'
+        # I guess this should really be the register owner's owner's name?
+        xml.spirit :name, try(:ip_name, :pdm_part_name) || owner.class.to_s.split('::').last
+        xml.spirit :version, try(:ip_version, :pdm_version, :pdm_cm_version, :version, :revision)
+        xml.spirit :memoryMaps do
+          memory_maps.each do |map_name, _map|
+            xml.spirit :memoryMap do
+              xml.spirit :name, map_name
+              address_blocks do |domain_name, _domain, sub_block|
+                xml.spirit :addressBlock do
+                  xml.spirit :name, address_block_name(domain_name, sub_block)
+                  xml.spirit :baseAddress, sub_block.base_address.to_hex
+                  xml.spirit :range, range(sub_block)
+                  xml.spirit :width, width(sub_block)
+                  sub_block.regs.each do |name, reg|
+                    # Required for now to ensure that the current value is the reset value
+                    reg.reset
+                    xml.spirit :register do
+                      xml.spirit :name, name
+                      xml.spirit :description, try(reg, :name_full, :full_name)
+                      xml.spirit :addressOffset, reg.offset.to_hex
+                      xml.spirit :size, reg.size
+                      if reg.bits.any?(&:writable?)
+                        xml.spirit :access, 'read-write'
+                      else
+                        xml.spirit :access, 'read-only'
+                      end
+                      xml.spirit :reset do
+                        xml.spirit :value, reg.data.to_hex
+                        xml.spirit :mask, mask(reg).to_hex
+                      end
+                      reg.named_bits do |name, bits|
+                        xml.spirit :field do
+                          xml.spirit :name, name
+                          xml.spirit :description, try(bits, :brief_description, :name_full, :full_name)
+                          xml.spirit :bitOffset, bits.position
+                          xml.spirit :bitWidth, bits.size
+                          xml.spirit :access, bits.access
+                          if options[:include_bit_field_values]
+                            if bits.bit_value_descriptions[0]
+                              bits.bit_value_descriptions.each do |val, desc|
+                                xml.spirit :values do
+                                  xml.spirit :value, val.to_hex
+                                  xml.spirit :name, "val_#{val.to_hex}"
+                                  xml.spirit :description, desc
+                                end
+                              end
+                            end
+                          end
+                          if uvm?
+                            xml.spirit :vendorExtensions do
+                              xml.vendorExtensions :hdl_path, bits.path(relative_to: sub_block)
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                  if uvm?
+                    xml.spirit :vendorExtensions do
+                      xml.vendorExtensions :hdl_path, sub_block.path(relative_to: owner)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def mask(reg)
+      m = 0
+      reg.size.times do |i|
+        unless reg[i].reset_val == :undefined
+          m |= (1 << i)
+        end
+      end
+      m
+    end
+
+    def uvm?
+      @format == :uvm
+    end
+
+    def memory_maps
+      { owner.name => {} }
+    end
+
+    def sub_blocks(domain_name)
+      owner.all_sub_blocks.select do |sub_block|
+        sub_block.owns_registers? &&
+          (sub_block.domains[domain_name] || domain_name == :default)
+      end
+    end
+
+    def address_blocks
+      domains = owner.register_domains
+      domains = { default: {} } if domains.empty?
+      domains.each do |domain_name, domain|
+        sub_blocks(domain_name).each do |sub_block|
+          yield domain_name, domain, sub_block
+        end
+      end
+    end
+
+    def address_block_name(domain_name, sub_block)
+      if domain_name == :default
+        sub_block.name.to_s
+      else
+        "#{domain_name}_#{sub_block.name}"
+      end
+    end
+
+    def width(sub_block)
+      sub_block.try(:width) || 32
+    end
+
+    def range(sub_block)
+      range = sub_block.try(:range) || begin
+        # This is to work around an Origen bug where max_address_reg_size is not updated in the case of
+        # only one register being present
+        # TODO: Fix in Origen
+        max_address_reg_size = sub_block.max_address_reg_size || sub_block.regs.first[1].size
+        (sub_block.max_reg_address + (max_address_reg_size / 8))
+      end
+      width_in_bytes = width(sub_block) / 8
+      if range % width_in_bytes != 0
+        range += (width_in_bytes - (range % width_in_bytes))
+      end
+      range
+    end
+  end
+end