1
            

            

            require 'origen'
          
        
      
        

          

            1
            

            

            require_relative '../config/application.rb'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            1
            

            

              autoload :XMLDoc,       'cross_origen/xml_doc'
          
        
      
        

          

            1
            

            

              autoload :Headers,      'cross_origen/headers'
          
        
      
        

          

            1
            

            

              autoload :Ralf,         'cross_origen/ralf'
          
        
      
        

          

            1
            

            

              autoload :IpXact,       'cross_origen/ip_xact'
          
        
      
        

          

            1
            

            

              autoload :DesignSync,   'cross_origen/design_sync'
          
        
      
        

          

            1
            

            

              autoload :CMSISSVD,     'cross_origen/cmsis_svd'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Basic object that is used to capture imported data and then export/save
          
        
      
        

          

            
            

            

              # it to Origen format
          
        
      
        

          

            1
            

            

              class Model
          
        
      
        

          

            1
            

            

                include Origen::Model
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns true if the --refresh switch was passed to the current Origen command
          
        
      
        

          

            1
            

            

              def self.refresh?
          
        
      
        

          

            15
            

            

                @refresh || false
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.include_timestamp?
          
        
      
        

          

            4
            

            

                instance_variable_defined?(:@include_timestamp) ? @include_timestamp : true
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.include_timestamp=(val)
          
        
      
        

          

            19
            

            

                @include_timestamp = val
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def instance_respond_to?(method_name)
          
        
      
        

          

            
            

            

                public_methods.include?(method_name)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def cr_import(options = {})
          
        
      
        

          

            
            

            

                options = {
          
        
      
        

          

            19
            

            

                  include_timestamp: true
          
        
      
        

          

            
            

            

                }.merge(options)
          
        
      
        

          

            19
            

            

                CrossOrigen.include_timestamp = options[:include_timestamp]
          
        
      
        

          

            19
            

            

                file = cr_file(options)
          
        
      
        

          

            19
            

            

                cr_translator(file, options).import(file, options)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def to_ralf(options = {})
          
        
      
        

          

            1
            

            

                cr_ralf.owner_to_ralf(options)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def to_ip_xact(options = {})
          
        
      
        

          

            4
            

            

                cr_ip_xact.owner_to_xml(options)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              alias_method :to_ipxact, :to_ip_xact
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def to_header(options = {})
          
        
      
        

          

            1
            

            

                cr_headers.owner_to_header(options)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Tries the given methods and returns the first one to return a value,
          
        
      
        

          

            
            

            

              # ultimately returns nil if no value is found.
          
        
      
        

          

            1
            

            

              def cr_try(*methods)
          
        
      
        

          

            2
            

            

                methods.each do |method|
          
        
      
        

          

            3
            

            

                  if self.respond_to?(method)
          
        
      
        

          

            2
            

            

                    val = send(method)
          
        
      
        

          

            2
            

            

                    return val if val
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                nil
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns an instance of the DesignSync interface
          
        
      
        

          

            1
            

            

              def cr_design_sync
          
        
      
        

          

            
            

            

                @cr_design_sync ||= DesignSync.new(self)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def cr_headers
          
        
      
        

          

            1
            

            

                @cr_headers ||= Headers.new(self)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def cr_ralf
          
        
      
        

          

            1
            

            

                @cr_ralf ||= Ralf.new(self)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def cr_ip_xact
          
        
      
        

          

            22
            

            

                @cr_ip_xact ||= IpXact.new(self)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def cr_cmsis_svd
          
        
      
        

          

            2
            

            

                @cr_cmsis_svd ||= CMSISSVD.new(self)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns an instance of the translator for the format of the given file
          
        
      
        

          

            1
            

            

              def cr_translator(file, options = {})
          
        
      
        

          

            19
            

            

                snippet = IO.read(file, 2000)  # Read first 2000 characters
          
        
      
        

          

            19
            

            

                case snippet
          
        
      
        

          

            
            

            

                when /spiritconsortium/
          
        
      
        

          

            17
            

            

                  cr_ip_xact
          
        
      
        

          

            
            

            

                when /CMSIS-SVD.xsd/
          
        
      
        

          

            2
            

            

                  cr_cmsis_svd
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  # 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
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns a local path to the given file defined by the options.
          
        
      
        

          

            1
            

            

              def cr_file(options = {})
          
        
      
        

          

            19
            

            

                if options[:path]
          
        
      
        

          

            19
            

            

                  options[:path]
          
        
      
        

          

            
            

            

                elsif options[:vault]
          
        
      
        

          

            
            

            

                  cr_design_sync.fetch(options)
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  fail 'You must supply a :path or :vault option pointing to the import file!'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            1
            

            

              class CMSISSVD < XMLDoc
          
        
      
        

          

            1
            

            

                def import(file, options = {}) # rubocop:disable CyclomaticComplexity
          
        
      
        

          

            2
            

            

                  filename = Pathname.new(file).basename('.*').to_s
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  unless options[:refresh] || CrossOrigen.refresh?
          
        
      
        

          

            
            

            

                    return if owner.import(filename, allow_missing: true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  model = CrossOrigen::Model.new
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  doc(file, options) do |doc|
          
        
      
        

          

            2
            

            

                    peripherals = peripherals(doc)
          
        
      
        

          

            8
            

            

                    groups = peripherals.values.map { |v| v[:group] }.uniq
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                    groups.each { |group| model.sub_block group }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                    peripherals.each do |name, attrs|
          
        
      
        

          

            6
            

            

                      base = attrs[:group] ? model.send(attrs[:group]) : model
          
        
      
        

          

            6
            

            

                      block = base.sub_block name, base_address: attrs[:base_address]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      if attrs[:parent]
          
        
      
        

          

            4
            

            

                        add_registers(block, find_peripheral_by_name(doc, attrs[:parent]))
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            6
            

            

                      add_registers(block, find_peripheral_by_name(doc, name))
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            2
            

            

                  model.export(filename, include_timestamp: CrossOrigen.include_timestamp?)
          
        
      
        

          

            2
            

            

                  owner.import(filename)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def add_registers(model, peripheral)
          
        
      
        

          

            10
            

            

                  peripheral.xpath('registers/register').each do |r|
          
        
      
        

          

            48
            

            

                    name = extract(r, 'name')
          
        
      
        

          

            48
            

            

                    di = extract(r, 'dim', format: :integer)
          
        
      
        

          

            48
            

            

                    dim = !!di
          
        
      
        

          

            48
            

            

                    if dim
          
        
      
        

          

            6
            

            

                      dinc = extract(r, 'dimIncrement', format: :integer)
          
        
      
        

          

            6
            

            

                      dvals = extract(r, 'dimIndex').split(',')
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            42
            

            

                      di = 1
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            48
            

            

                    offset = extract(r, 'addressOffset', format: :integer, hex: true)
          
        
      
        

          

            48
            

            

                    size = extract(r, 'size', format: :integer)
          
        
      
        

          

            48
            

            

                    reset = extract(r, 'resetValue', format: :integer, hex: true)
          
        
      
        

          

            48
            

            

                    desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            48
            

            

                    di.times do |i|
          
        
      
        

          

            66
            

            

                      if dim
          
        
      
        

          

            24
            

            

                        n = name.sub('[%s]', dvals[i])
          
        
      
        

          

            24
            

            

                        addr = offset + (i * dinc)
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            42
            

            

                        n = name
          
        
      
        

          

            42
            

            

                        addr = offset
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                      opts = {
          
        
      
        

          

            66
            

            

                        size:        size,
          
        
      
        

          

            
            

            

                        description: desc
          
        
      
        

          

            
            

            

                      }
          
        
      
        

          

            66
            

            

                      opts[:reset] = reset if reset
          
        
      
        

          

            66
            

            

                      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
          
        
      
        

          

            66
            

            

                      model.del_reg(reg_name) if model.has_reg?(reg_name)
          
        
      
        

          

            66
            

            

                      model.reg reg_name, addr, opts do |reg|
          
        
      
        

          

            66
            

            

                        r.xpath('fields/field').each do |b|
          
        
      
        

          

            120
            

            

                          bn = extract(b, 'name')
          
        
      
        

          

            120
            

            

                          unless bn == 'RESERVED'
          
        
      
        

          

            120
            

            

                            bn = bn.to_s.downcase.symbolize
          
        
      
        

          

            120
            

            

                            lsb = extract(b, 'lsb', format: :integer)
          
        
      
        

          

            120
            

            

                            msb = extract(b, 'msb', format: :integer)
          
        
      
        

          

            120
            

            

                            unless lsb
          
        
      
        

          

            120
            

            

                              lsb = extract(b, 'bitOffset', format: :integer)
          
        
      
        

          

            120
            

            

                              if lsb
          
        
      
        

          

            
            

            

                                msb = lsb + extract(b, 'msb', format: :integer) - 1
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            120
            

            

                            unless lsb
          
        
      
        

          

            120
            

            

                              range = extract(b, 'bitRange')
          
        
      
        

          

            120
            

            

                              range =~ /\[(\d+):(\d+)\]/
          
        
      
        

          

            120
            

            

                              lsb = Regexp.last_match(2).to_i
          
        
      
        

          

            120
            

            

                              msb = Regexp.last_match(1).to_i
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            120
            

            

                            access = extract(b, 'access')
          
        
      
        

          

            120
            

            

                            desc = (extract(r, 'description') || '').gsub("'", %q(\\\'))
          
        
      
        

          

            120
            

            

                            case access
          
        
      
        

          

            
            

            

                            when 'read-only'
          
        
      
        

          

            18
            

            

                              ac = :ro
          
        
      
        

          

            
            

            

                            else
          
        
      
        

          

            102
            

            

                              ac = :rw
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            120
            

            

                            if lsb == msb
          
        
      
        

          

            60
            

            

                              reg.bit lsb, bn, access: ac, description: desc
          
        
      
        

          

            
            

            

                            else
          
        
      
        

          

            60
            

            

                              reg.bit msb..lsb, bn, access: ac, description: desc
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def find_peripheral_by_name(doc, pname)
          
        
      
        

          

            10
            

            

                  doc.xpath('device/peripherals/peripheral').find do |peripheral|
          
        
      
        

          

            16
            

            

                    pname == name(peripheral)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def clean_name(name)
          
        
      
        

          

            32
            

            

                  name = name.to_s
          
        
      
        

          

            32
            

            

                  unless name.empty?
          
        
      
        

          

            28
            

            

                    name.downcase.symbolize
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def name(peripheral)
          
        
      
        

          

            22
            

            

                  clean_name(fetch(peripheral.xpath('name'), get_text: true))
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def group_name(peripheral)
          
        
      
        

          

            6
            

            

                  clean_name(fetch(peripheral.xpath('groupName'), get_text: true))
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def parent(peripheral)
          
        
      
        

          

            6
            

            

                  a = peripheral.attributes['derivedFrom']
          
        
      
        

          

            6
            

            

                  a ? clean_name(a.value) : nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def base_address(peripheral)
          
        
      
        

          

            6
            

            

                  extract(peripheral, 'baseAddress', format: :integer, hex: true)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def peripherals(doc)
          
        
      
        

          

            2
            

            

                  peripherals = {}
          
        
      
        

          

            2
            

            

                  doc.xpath('device/peripherals/peripheral').each do |peripheral|
          
        
      
        

          

            6
            

            

                    peripherals[name(peripheral)] = {
          
        
      
        

          

            
            

            

                      group:        group_name(peripheral),
          
        
      
        

          

            
            

            

                      parent:       parent(peripheral),
          
        
      
        

          

            
            

            

                      base_address: base_address(peripheral)
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  # Inherit missing values from parents...
          
        
      
        

          

            2
            

            

                  p = {}
          
        
      
        

          

            2
            

            

                  peripherals.each do |k, v|
          
        
      
        

          

            6
            

            

                    v[:group] ||= peripherals[v[:parent]][:group]
          
        
      
        

          

            6
            

            

                    v[:base_address] ||= peripherals[v[:parent]][:base_address]
          
        
      
        

          

            6
            

            

                    p[k] = v
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            2
            

            

                  p
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            
            

            

              # Driver for talking to DesignSync
          
        
      
        

          

            1
            

            

              class DesignSync
          
        
      
        

          

            1
            

            

                require 'digest/sha1'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns the object that included the CrossOrigen module
          
        
      
        

          

            1
            

            

                attr_reader :owner
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(owner)
          
        
      
        

          

            
            

            

                  @owner = owner
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def driver
          
        
      
        

          

            
            

            

                  @driver ||= Origen::Utility::DesignSync.new
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns a full path to the Design Sync import (cache) directory
          
        
      
        

          

            1
            

            

                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.
          
        
      
        

          

            1
            

            

                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
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            1
            

            

              class Headers
          
        
      
        

          

            
            

            

                # Returns the object that included the CrossOrigen module
          
        
      
        

          

            1
            

            

                attr_reader :owner
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(owner)
          
        
      
        

          

            1
            

            

                  @owner = owner
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns a string representing the owner as a C header
          
        
      
        

          

            1
            

            

                def owner_to_header(_options = {})
          
        
      
        

          

            1
            

            

                  Origen.compile("#{path_to_templates}/headers/default.h.erb", scope: owner)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def path_to_templates
          
        
      
        

          

            1
            

            

                  "#{File.expand_path(File.dirname(__FILE__))}/../../templates"
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            1
            

            

              class IpXact < XMLDoc
          
        
      
        

          

            1
            

            

                AddressSpace = Struct.new(:name, :range, :width)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                MemoryMaps = Struct.new(:name, :address_blocks)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                AddressBlock = Struct.new(:name, :base_address, :range, :width)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Create a shorthand way to reference Origen Core's Bit ACCESS_CODES
          
        
      
        

          

            1
            

            

                @@access_hash = Origen::Registers::Bit.const_get(:ACCESS_CODES)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Import/reader that currently only supports creating registers and bit fields
          
        
      
        

          

            1
            

            

                def import(file, options = {}) # rubocop:disable CyclomaticComplexity
          
        
      
        

          

            17
            

            

                  require 'kramdown'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            17
            

            

                  filename = Pathname.new(file).basename('.*').to_s
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            17
            

            

                  unless options[:refresh] || CrossOrigen.refresh?
          
        
      
        

          

            15
            

            

                    return if owner.import(filename, allow_missing: true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  model = CrossOrigen::Model.new
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  address_spaces = {}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                  doc(file, options) do |doc|
          
        
      
        

          

            2
            

            

                    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
          
        
      
        

          

            2
            

            

                    open_memory_map(doc) do |mem_map|
          
        
      
        

          

            2
            

            

                      if mem_map
          
        
      
        

          

            2
            

            

                        mem_map_name = fetch mem_map.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
          
        
      
        

          

            2
            

            

                        if mem_map_name.to_s.empty?
          
        
      
        

          

            
            

            

                          mem_map_obj = model
          
        
      
        

          

            
            

            

                        else
          
        
      
        

          

            2
            

            

                          model.sub_block mem_map_name
          
        
      
        

          

            2
            

            

                          mem_map_obj = model.send(mem_map_name)
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            2
            

            

                        addr_blocks = mem_map.xpath('spirit:addressBlock')
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            
            

            

                        mem_map_obj = model
          
        
      
        

          

            
            

            

                        addr_blocks = doc.xpath('//spirit:addressBlock')
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            2
            

            

                      addr_blocks.each do |addr_block|
          
        
      
        

          

            2
            

            

                        name = fetch addr_block.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
          
        
      
        

          

            2
            

            

                        base_address = fetch addr_block.at_xpath('spirit:baseAddress'), get_text: true, to_dec: true
          
        
      
        

          

            2
            

            

                        range = fetch addr_block.at_xpath('spirit:range'), get_text: true, to_dec: true
          
        
      
        

          

            2
            

            

                        width = fetch addr_block.at_xpath('spirit:width'), get_text: true, to_i: true
          
        
      
        

          

            2
            

            

                        if name.to_s.empty?
          
        
      
        

          

            2
            

            

                          addr_block_obj = mem_map_obj
          
        
      
        

          

            
            

            

                        else
          
        
      
        

          

            
            

            

                          mem_map_obj.sub_block name, base_address: base_address, range: range, lau: width
          
        
      
        

          

            
            

            

                          addr_block_obj = mem_map_obj.send(name)
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            2
            

            

                        addr_block.xpath('spirit:register').each do |register|
          
        
      
        

          

            4
            

            

                          name = fetch register.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
          
        
      
        

          

            4
            

            

                          size = fetch register.at_xpath('spirit:size'), get_text: true, to_i: true
          
        
      
        

          

            4
            

            

                          addr_offset = fetch register.at_xpath('spirit:addressOffset'), get_text: true, to_dec: true
          
        
      
        

          

            4
            

            

                          access = fetch register.at_xpath('spirit:access'), get_text: true
          
        
      
        

          

            
            

            

                          # Determine if a reset is defined for the register
          
        
      
        

          

            4
            

            

                          if register.at_xpath('spirit:reset').nil?
          
        
      
        

          

            
            

            

                            # If a reset does not exist, need to set the reset_value to 0, as Origen does not (yet) have a concept
          
        
      
        

          

            
            

            

                            # of a register without a reset.
          
        
      
        

          

            
            

            

                            reset_value = 0
          
        
      
        

          

            
            

            

                          else
          
        
      
        

          

            
            

            

                            # If a reset exists, determine the reset_value (required) and reset_mask (if defined)
          
        
      
        

          

            4
            

            

                            reset_value = fetch register.at_xpath('spirit:reset/spirit:value'), get_text: true, to_dec: true
          
        
      
        

          

            4
            

            

                            reset_mask = fetch register.at_xpath('spirit:reset/spirit:mask'), get_text: true, to_dec: true
          
        
      
        

          

            
            

            

                            # Issue #8 fix - reset_mask is optional, keep reset value as imported when a mask is not defined.
          
        
      
        

          

            
            

            

                            # Only perform AND-ing if mask is defined.  Only zero-out the reset_value if reset_value was nil.
          
        
      
        

          

            4
            

            

                            if reset_value.nil?
          
        
      
        

          

            
            

            

                              # Set default for reset_value attribute if none was provided and issue a warning.
          
        
      
        

          

            
            

            

                              reset_value = 0
          
        
      
        

          

            
            

            

                              Origen.log.warning "Register #{name.upcase} was defined as having a reset, but did not have a defined reset value.  This is not compliant with IP-XACT standard."
          
        
      
        

          

            
            

            

                              Origen.log.warning "The reset value for #{name.upcase} has been defined as 0x0 as a result."
          
        
      
        

          

            4
            

            

                            elsif reset_mask.nil?
          
        
      
        

          

            
            

            

                              # If mask is undefined, leave reset_value alone.
          
        
      
        

          

            
            

            

                            else
          
        
      
        

          

            
            

            

                              # Do a logical bitwise AND with the reset value and mask
          
        
      
        

          

            4
            

            

                              reset_value = reset_value & reset_mask
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                          # Future expansion: pull in HDL path as abs_path in Origen.
          
        
      
        

          

            4
            

            

                          addr_block_obj.reg name, addr_offset, size: size, access: access, description: reg_description(register) do |reg|
          
        
      
        

          

            4
            

            

                            register.xpath('spirit:field').each do |field|
          
        
      
        

          

            60
            

            

                              name = fetch field.at_xpath('spirit:name'), downcase: true, to_sym: true, get_text: true
          
        
      
        

          

            60
            

            

                              bit_offset = fetch field.at_xpath('spirit:bitOffset'), get_text: true, to_i: true
          
        
      
        

          

            60
            

            

                              bit_width = fetch field.at_xpath('spirit:bitWidth'), get_text: true, to_i: true
          
        
      
        

          

            60
            

            

                              xml_access = fetch field.at_xpath('spirit:access'), get_text: true
          
        
      
        

          

            
            

            

                              # Newer IP-XACT standards list access as < read or write>-< descriptor >, such as
          
        
      
        

          

            
            

            

                              # "read-write", "read-only", or "read-writeOnce"
          
        
      
        

          

            60
            

            

                              if xml_access =~ /\S+\-\S+/ || xml_access == 'writeOnce'
          
        
      
        

          

            
            

            

                                # This filter alone is not capable of interpreting the 1685-2009 (and 2014).  Therefore
          
        
      
        

          

            
            

            

                                # must reverse-interpret the content of access_hash (see top of file).
          
        
      
        

          

            
            

            

                                #
          
        
      
        

          

            
            

            

                                # First get the base access type, ie: read-write, read-only, etc.
          
        
      
        

          

            
            

            

                                # base_access = fetch field.at_xpath('spirit:access'), get_text: true
          
        
      
        

          

            30
            

            

                                base_access = xml_access
          
        
      
        

          

            
            

            

                                # Next grab any modified write values or read actions
          
        
      
        

          

            30
            

            

                                mod_write = fetch field.at_xpath('spirit:modifiedWriteValue'), get_text: true
          
        
      
        

          

            30
            

            

                                read_action = fetch field.at_xpath('spirit:readAction'), get_text: true
          
        
      
        

          

            
            

            

                                # Using base_access, mod_write, and read_action, look up the corresponding access
          
        
      
        

          

            
            

            

                                # acronym from access_hash, noting it is not possible to differentiate write-only
          
        
      
        

          

            
            

            

                                # from write-only, read zero and read-write from dc.
          
        
      
        

          

            
            

            

                                #
          
        
      
        

          

            
            

            

                                # Matched needs to be tracked, as there is no way to differentiate :rw and :dc in IP-XACT.
          
        
      
        

          

            
            

            

                                # Everything imported will default to :rw, never :dc.
          
        
      
        

          

            30
            

            

                                matched = false
          
        
      
        

          

            30
            

            

                                @@access_hash.each_key do |key|
          
        
      
        

          

            840
            

            

                                  if @@access_hash[key][:base] == base_access && @@access_hash[key][:write] == mod_write && @@access_hash[key][:read] == read_action && !matched
          
        
      
        

          

            30
            

            

                                    access = key.to_sym
          
        
      
        

          

            30
            

            

                                    matched = true
          
        
      
        

          

            
            

            

                                  end
          
        
      
        

          

            
            

            

                                end
          
        
      
        

          

            
            

            

                              # Older IP-XACT standards appear to also accept short acronyms like "ro", "w1c", "rw",
          
        
      
        

          

            
            

            

                              # etc.
          
        
      
        

          

            30
            

            

                              elsif xml_access =~ /\S+/
          
        
      
        

          

            30
            

            

                                access = xml_access.downcase.to_sym
          
        
      
        

          

            
            

            

                              else
          
        
      
        

          

            
            

            

                                # default to read-write if access is not specified
          
        
      
        

          

            
            

            

                                access = :rw
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            60
            

            

                              range = nil
          
        
      
        

          

            60
            

            

                              if bit_width == 1
          
        
      
        

          

            58
            

            

                                range = bit_offset
          
        
      
        

          

            
            

            

                              else
          
        
      
        

          

            2
            

            

                                range = (bit_offset + bit_width - 1)..bit_offset
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            60
            

            

                              reg.bit range, name, reset: reset_value[range], access: access, description: bit_description(field)
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            2
            

            

                  model.export(filename, include_timestamp: CrossOrigen.include_timestamp?)
          
        
      
        

          

            2
            

            

                  owner.import(filename, options)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                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
          
        
      
        

          

            2
            

            

                  if options[:fragment]
          
        
      
        

          

            
            

            

                    require 'nokogiri'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    content = %(
          
        
      
        

          

            
            

            

            <?xml version="1.0"?>
          
        
      
        

          

            
            

            

            <spirit:component xmlns:spirit="https://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4"
          
        
      
        

          

            
            

            

            xmlns:xsi="https://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
          
        
      
        

          

            2
            

            

                    super
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns a string representing the owner object in IP-XACT XML
          
        
      
        

          

            
            

            

                # Usable / Available options:
          
        
      
        

          

            
            

            

                #   :vendor             = Company name/web address, ex: 'nxp.com'
          
        
      
        

          

            
            

            

                #   :library            = IP Library
          
        
      
        

          

            
            

            

                #   :schema             = '1685-2009' or default of Spirit 1.4 (when no :schema option passed)
          
        
      
        

          

            
            

            

                #   :bus_interface      = only 'AMBA3' supported at this time
          
        
      
        

          

            
            

            

                #   :mmap_name          = Optionally set the memoryMap name to something other than the module name
          
        
      
        

          

            
            

            

                #   :mmap_ref           = memoryMapRef name, ex: 'UserMap'
          
        
      
        

          

            
            

            

                #   :addr_block_name    = addressBlock -> Name, ex: 'ATX'
          
        
      
        

          

            1
            

            

                def owner_to_xml(options = {})
          
        
      
        

          

            4
            

            

                  require 'nokogiri'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  options = {
          
        
      
        

          

            4
            

            

                    include_bit_field_values: true
          
        
      
        

          

            
            

            

                  }.merge(options)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  @format = options[:format]
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Compatible schemas: Spirit 1.4, 1685-2009
          
        
      
        

          

            
            

            

                  # Assume Spirit 1.4 if no schema provided
          
        
      
        

          

            4
            

            

                  if options[:schema] == '1685-2009' # Magillem tool uses alternate schema
          
        
      
        

          

            
            

            

                    schemas = [
          
        
      
        

          

            2
            

            

                      'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1685-2009',
          
        
      
        

          

            
            

            

                      'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1685-2009/index.xsd'
          
        
      
        

          

            
            

            

                    ]
          
        
      
        

          

            
            

            

                  else # Assume Spirit 1.4 if not
          
        
      
        

          

            
            

            

                    schemas = [
          
        
      
        

          

            2
            

            

                      'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4',
          
        
      
        

          

            
            

            

                      'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4/index.xsd'
          
        
      
        

          

            
            

            

                    ]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  if uvm? && !(options[:schema] == '1685-2009')
          
        
      
        

          

            1
            

            

                    schemas << '$IREG_GEN/XMLSchema/SPIRIT/VendorExtensions.xsd'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  if options[:schema] == '1685-2009' # Magillem tool uses alternate schema
          
        
      
        

          

            
            

            

                    headers = {
          
        
      
        

          

            2
            

            

                      'xmlns:spirit'       => 'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1685-2009',
          
        
      
        

          

            
            

            

                      'xmlns:xsi'          => 'https://www.w3.org/2001/XMLSchema-instance',
          
        
      
        

          

            
            

            

                      'xsi:schemaLocation' => schemas.join(' ')
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  else # Assume Spirit 1.4 if not
          
        
      
        

          

            
            

            

                    headers = {
          
        
      
        

          

            2
            

            

                      'xmlns:spirit'       => 'https://www.spiritconsortium.org/XMLSchema/SPIRIT/1.4',
          
        
      
        

          

            
            

            

                      'xmlns:xsi'          => 'https://www.w3.org/2001/XMLSchema-instance',
          
        
      
        

          

            
            

            

                      'xsi:schemaLocation' => schemas.join(' ')
          
        
      
        

          

            
            

            

                    }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  if uvm? && !(options[:schema] == '1685-2009')
          
        
      
        

          

            1
            

            

                    headers['xmlns:vendorExtensions'] = '$IREG_GEN/XMLSchema/SPIRIT'
          
        
      
        

          

            
            

            

                    # Else:
          
        
      
        

          

            
            

            

                    # Do nothing ?
          
        
      
        

          

            
            

            

                    # headers['xmlns:vendorExtensions'] = '$UVM_RGM_HOME/builder/ipxact/schema'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
          
        
      
        

          

            4
            

            

                    spirit = xml['spirit']
          
        
      
        

          

            4
            

            

                    spirit.component(headers) do
          
        
      
        

          

            4
            

            

                      spirit.vendor options[:vendor] || 'Origen'
          
        
      
        

          

            4
            

            

                      spirit.library options[:library] || 'Origen'
          
        
      
        

          

            
            

            

                      # I guess this should really be the register owner's owner's name?
          
        
      
        

          

            4
            

            

                      spirit.name try(:ip_name) || owner.class.to_s.split('::').last
          
        
      
        

          

            4
            

            

                      spirit.version try(:ip_version, :version, :revision)
          
        
      
        

          

            
            

            

                      # The 1685-2009 schema allows for a bus interface.  AMBA3 (slave) supported so far.
          
        
      
        

          

            4
            

            

                      if options[:schema] == '1685-2009'
          
        
      
        

          

            2
            

            

                        if options[:bus_interface] == 'AMBA3'
          
        
      
        

          

            1
            

            

                          spirit.busInterfaces do
          
        
      
        

          

            1
            

            

                            spirit.busInterface do
          
        
      
        

          

            1
            

            

                              spirit.name 'Slave'
          
        
      
        

          

            
            

            

                              bustype_header = {
          
        
      
        

          

            1
            

            

                                'spirit:vendor'  => options[:vendor] || 'Origen',
          
        
      
        

          

            
            

            

                                'spirit:library' => 'amba3',
          
        
      
        

          

            
            

            

                                'spirit:name'    => 'APB3',
          
        
      
        

          

            
            

            

                                'spirit:version' => '1.0'
          
        
      
        

          

            
            

            

                              }
          
        
      
        

          

            1
            

            

                              xml['spirit'].busType bustype_header
          
        
      
        

          

            1
            

            

                              spirit.slave do
          
        
      
        

          

            
            

            

                                mmapref_header = {
          
        
      
        

          

            1
            

            

                                  'spirit:memoryMapRef' => options[:mmap_ref] || 'APB'
          
        
      
        

          

            
            

            

                                }
          
        
      
        

          

            1
            

            

                                xml['spirit'].memoryMapRef mmapref_header
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            4
            

            

                      spirit.memoryMaps do
          
        
      
        

          

            4
            

            

                        memory_maps.each do |map_name, _map|
          
        
      
        

          

            4
            

            

                          spirit.memoryMap do
          
        
      
        

          

            
            

            

                            # Optionally assign memory map name to something other than the module name in Ruby,
          
        
      
        

          

            
            

            

                            # default to 'RegisterMap'
          
        
      
        

          

            4
            

            

                            spirit.name options[:mmap_name] || 'RegisterMap'
          
        
      
        

          

            4
            

            

                            address_blocks do |domain_name, _domain, sub_block|
          
        
      
        

          

            10
            

            

                              spirit.addressBlock do
          
        
      
        

          

            
            

            

                                # When registers reside at the top level, do not assign an address block name
          
        
      
        

          

            10
            

            

                                if sub_block == owner
          
        
      
        

          

            4
            

            

                                  if options[:addr_block_name].nil?
          
        
      
        

          

            4
            

            

                                    spirit.name nil
          
        
      
        

          

            
            

            

                                  else
          
        
      
        

          

            
            

            

                                    spirit.name options[:addr_block_name]
          
        
      
        

          

            
            

            

                                  end
          
        
      
        

          

            
            

            

                                else
          
        
      
        

          

            6
            

            

                                  spirit.name address_block_name(domain_name, sub_block)
          
        
      
        

          

            
            

            

                                end
          
        
      
        

          

            10
            

            

                                spirit.baseAddress sub_block.base_address.to_hex
          
        
      
        

          

            10
            

            

                                spirit.range range(sub_block)
          
        
      
        

          

            10
            

            

                                spirit.width width(sub_block)
          
        
      
        

          

            10
            

            

                                sub_block.regs.each do |name, reg|
          
        
      
        

          

            
            

            

                                  # Required for now to ensure that the current value is the reset value
          
        
      
        

          

            30
            

            

                                  reg.reset
          
        
      
        

          

            30
            

            

                                  spirit.register do
          
        
      
        

          

            30
            

            

                                    spirit.name name
          
        
      
        

          

            30
            

            

                                    spirit.description try(reg, :name_full, :full_name)
          
        
      
        

          

            30
            

            

                                    spirit.addressOffset reg.offset.to_hex
          
        
      
        

          

            30
            

            

                                    spirit.size reg.size
          
        
      
        

          

            30
            

            

                                    if reg.bits.any?(&:writable?)
          
        
      
        

          

            26
            

            

                                      spirit.access 'read-write'
          
        
      
        

          

            
            

            

                                    else
          
        
      
        

          

            4
            

            

                                      spirit.access 'read-only'
          
        
      
        

          

            
            

            

                                    end
          
        
      
        

          

            30
            

            

                                    spirit.reset do
          
        
      
        

          

            30
            

            

                                      spirit.value reg.data.to_hex
          
        
      
        

          

            30
            

            

                                      spirit.mask mask(reg).to_hex
          
        
      
        

          

            
            

            

                                    end
          
        
      
        

          

            30
            

            

                                    reg.named_bits do |name, bits|
          
        
      
        

          

            162
            

            

                                      spirit.field do
          
        
      
        

          

            162
            

            

                                        spirit.name name
          
        
      
        

          

            162
            

            

                                        spirit.description try(bits, :brief_description, :name_full, :full_name)
          
        
      
        

          

            162
            

            

                                        spirit.bitOffset bits.position
          
        
      
        

          

            162
            

            

                                        spirit.bitWidth bits.size
          
        
      
        

          

            
            

            

                                        # When exporting to 1685-2009 schema, need to handle special cases (writeOnce),
          
        
      
        

          

            
            

            

                                        # modifiedWriteValue, and readAction fields.
          
        
      
        

          

            162
            

            

                                        if options[:schema] == '1685-2009'
          
        
      
        

          

            81
            

            

                                          if bits.writable? && bits.readable?
          
        
      
        

          

            58
            

            

                                            if bits.access == :w1
          
        
      
        

          

            2
            

            

                                              spirit.access 'read-writeOnce'
          
        
      
        

          

            
            

            

                                            else
          
        
      
        

          

            56
            

            

                                              spirit.access 'read-write'
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            23
            

            

                                          elsif bits.writable?
          
        
      
        

          

            11
            

            

                                            if bits.access == :wo1
          
        
      
        

          

            2
            

            

                                              spirit.access 'writeOnce'
          
        
      
        

          

            
            

            

                                            else
          
        
      
        

          

            9
            

            

                                              spirit.access 'write-only'
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            12
            

            

                                          elsif bits.readable?
          
        
      
        

          

            12
            

            

                                            spirit.access 'read-only'
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            81
            

            

                                          if bits.readable?
          
        
      
        

          

            70
            

            

                                            unless @@access_hash[bits.access][:read].nil?
          
        
      
        

          

            22
            

            

                                              spirit.readAction @@access_hash[bits.access][:read]
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            81
            

            

                                          if bits.writable?
          
        
      
        

          

            69
            

            

                                            unless @@access_hash[bits.access][:write].nil?
          
        
      
        

          

            32
            

            

                                              spirit.modifiedWriteValue @@access_hash[bits.access][:write]
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            
            

            

                                        else # Assume Spirit 1.4 if not
          
        
      
        

          

            81
            

            

                                          spirit.access bits.access
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            
            

            

                                        # HDL paths provide hooks for a testbench to directly manipulate the
          
        
      
        

          

            
            

            

                                        # registers without having to go through a bus interface or read/write
          
        
      
        

          

            
            

            

                                        # protocol.  Because the hierarchical path to a register block can vary
          
        
      
        

          

            
            

            

                                        # greatly between devices, allow the user to provide an abs_path value
          
        
      
        

          

            
            

            

                                        # and define "full_reg_path" to assist.
          
        
      
        

          

            
            

            

                                        #
          
        
      
        

          

            
            

            

                                        # When registers reside at the top level without a specified path, use 'top'.
          
        
      
        

          

            162
            

            

                                        if reg.owner.path.nil? || reg.owner.path.empty?
          
        
      
        

          

            8
            

            

                                          regpath = 'top'
          
        
      
        

          

            
            

            

                                        else
          
        
      
        

          

            154
            

            

                                          regpath = reg.owner.path
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            
            

            

                                        # If :full_reg_path is defined, the :abs_path metadata for a register will
          
        
      
        

          

            
            

            

                                        # be used for regpath.  This can be assigned at an address block (sub-block)
          
        
      
        

          

            
            

            

                                        # level.
          
        
      
        

          

            162
            

            

                                        unless options[:full_reg_path].nil? == true
          
        
      
        

          

            
            

            

                                          regpath = reg.path
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            162
            

            

                                        if options[:schema] == '1685-2009'
          
        
      
        

          

            81
            

            

                                          spirit.parameters do
          
        
      
        

          

            81
            

            

                                            spirit.parameter do
          
        
      
        

          

            81
            

            

                                              spirit.name '_hdlPath_'
          
        
      
        

          

            
            

            

                                              # HDL path needs to be to the declared bit field name, NOT to the bus slice
          
        
      
        

          

            
            

            

                                              # that Origen's "abs_path" will yield.  Ex:
          
        
      
        

          

            
            

            

                                              #
          
        
      
        

          

            
            

            

                                              # ~~~ ruby
          
        
      
        

          

            
            

            

                                              # reg :myreg, 0x0, size: 32 do |reg|
          
        
      
        

          

            
            

            

                                              #   bits 7..4, :bits_high
          
        
      
        

          

            
            

            

                                              #   bits 3..0, :bits_low
          
        
      
        

          

            
            

            

                                              # end
          
        
      
        

          

            
            

            

                                              # ~~~
          
        
      
        

          

            
            

            

                                              #
          
        
      
        

          

            
            

            

                                              # The abs_path to ...regs(:myreg).bits(:bits_low).abs_path will yield
          
        
      
        

          

            
            

            

                                              # "myreg.myreg[3:0]", not "myreg.bits_low".  This is not an understood path
          
        
      
        

          

            
            

            

                                              # in Origen (myreg[3:0] does not exist in either myreg's RegCollection or BitCollection),
          
        
      
        

          

            
            

            

                                              # and does not sync with how RTL would create bits_low[3:0].
          
        
      
        

          

            
            

            

                                              # Therefore, use the path to "myreg"'s owner appended with bits.name (bits_low here).
          
        
      
        

          

            
            

            

                                              #
          
        
      
        

          

            
            

            

                                              # This can be done in a register or sub_blocks definition by defining register
          
        
      
        

          

            
            

            

                                              # metadata for "abs_path".  If the reg owner's path weren't used, but instead the
          
        
      
        

          

            
            

            

                                              # reg's path, that would imply each register was a separate hierarchical path in
          
        
      
        

          

            
            

            

                                              # RTL (ex: "top.myblock.regblock.myreg.myreg_bits"), which is normally not the case.
          
        
      
        

          

            
            

            

                                              # The most likely path would be "top.myblock.regblock.myreg_bits.
          
        
      
        

          

            81
            

            

                                              spirit.value "#{regpath}.#{bits.name}"
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            
            

            

                                        # C. Hume - Unclear which vendorExtensions should be included by default, if any.
          
        
      
        

          

            
            

            

                                        # Future improvment: Allow passing of vendorExtensions enable & value hash/string
          
        
      
        

          

            
            

            

                                        # if options[:schema] == '1685-2009'
          
        
      
        

          

            
            

            

                                        #   spirit.vendorExtensions do
          
        
      
        

          

            
            

            

                                        #     vendorext = { 'xmlns:vendorExtensions' => '$UVM_RGM_HOME/builder/ipxact/schema' }
          
        
      
        

          

            
            

            

                                        #     xml['vendorExtensions'].hdl_path vendorext, "#{reg.path}.#{bits.name}"
          
        
      
        

          

            
            

            

                                        #   end
          
        
      
        

          

            
            

            

                                        # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                                        # Allow optional inclusion of bit field values and descriptions
          
        
      
        

          

            162
            

            

                                        if options[:include_bit_field_values]
          
        
      
        

          

            162
            

            

                                          if bits.bit_value_descriptions[0]
          
        
      
        

          

            4
            

            

                                            bits.bit_value_descriptions.each do |val, desc|
          
        
      
        

          

            8
            

            

                                              spirit.values do
          
        
      
        

          

            8
            

            

                                                spirit.value val.to_hex
          
        
      
        

          

            8
            

            

                                                spirit.name "val_#{val.to_hex}"
          
        
      
        

          

            8
            

            

                                                spirit.description desc
          
        
      
        

          

            
            

            

                                              end
          
        
      
        

          

            
            

            

                                            end
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            162
            

            

                                        if uvm? && !(options[:schema] == '1685-2009')
          
        
      
        

          

            51
            

            

                                          spirit.vendorExtensions do
          
        
      
        

          

            51
            

            

                                            xml['vendorExtensions'].hdl_path "#{regpath}.#{bits.name}"
          
        
      
        

          

            
            

            

                                          end
          
        
      
        

          

            
            

            

                                        end
          
        
      
        

          

            
            

            

                                      end
          
        
      
        

          

            
            

            

                                    end
          
        
      
        

          

            
            

            

                                  end
          
        
      
        

          

            
            

            

                                end
          
        
      
        

          

            
            

            

                                # Unclear whether addressBlock vendor extensions are supported in Spirit 1.4
          
        
      
        

          

            
            

            

                                # if uvm?
          
        
      
        

          

            
            

            

                                #  spirit.vendorExtensions do
          
        
      
        

          

            
            

            

                                #    xml['vendorExtensions'].hdl_path sub_block.path(relative_to: owner)
          
        
      
        

          

            
            

            

                                #  end
          
        
      
        

          

            
            

            

                                # end
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                            # Assume byte addressing if not specified
          
        
      
        

          

            4
            

            

                            if owner.methods.include?(:lau) == false
          
        
      
        

          

            4
            

            

                              if methods.include?(:lau) == true
          
        
      
        

          

            
            

            

                                spirit.addressUnitBits lau
          
        
      
        

          

            
            

            

                              else
          
        
      
        

          

            4
            

            

                                spirit.addressUnitBits 8
          
        
      
        

          

            
            

            

                              end
          
        
      
        

          

            
            

            

                            else
          
        
      
        

          

            
            

            

                              spirit.addressUnitBits owner.lau
          
        
      
        

          

            
            

            

                            end
          
        
      
        

          

            
            

            

                          end
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  # When testing with 'origen examples', travis_ci (bash) will end up with empty tags -
          
        
      
        

          

            
            

            

                  # '<spirit:description/>' that do not appear on some user's tshell environments.  To
          
        
      
        

          

            
            

            

                  # prevent false errors for this issue, force Nokogiri to use self-closing tags
          
        
      
        

          

            
            

            

                  # ('<spirit:description></spirit:description>'), but keep the XML formatted for readability.
          
        
      
        

          

            
            

            

                  # All tags with no content will appear as '<spirit:tag_name></spirit:tag_name>'.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            4
            

            

                  builder.to_xml(save_with: Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
          
        
      
        

          

            
            

            

                                            Nokogiri::XML::Node::SaveOptions::FORMAT)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def open_memory_map(doc)
          
        
      
        

          

            2
            

            

                  maps = doc.xpath('//spirit:memoryMaps/spirit:memoryMap')
          
        
      
        

          

            2
            

            

                  maps = [nil] if maps.empty?
          
        
      
        

          

            2
            

            

                  maps.each do |mem_map|
          
        
      
        

          

            2
            

            

                    yield mem_map
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def reg_description(register)
          
        
      
        

          

            4
            

            

                  fetch register.at_xpath('spirit:description'), get_text: true, whitespace: true
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def bit_description(bit)
          
        
      
        

          

            60
            

            

                  desc = fetch(bit.at_xpath('spirit:description'), get_text: true, whitespace: true) || ''
          
        
      
        

          

            60
            

            

                  bit_val_present = false
          
        
      
        

          

            60
            

            

                  bit.xpath('spirit:values').each do |val|
          
        
      
        

          

            4
            

            

                    unless bit_val_present
          
        
      
        

          

            2
            

            

                      desc += "\n"
          
        
      
        

          

            2
            

            

                      bit_val_present = true
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            4
            

            

                    value = extract(val, 'spirit:value', format: :integer, hex: true)
          
        
      
        

          

            4
            

            

                    value_desc = extract val, 'spirit:description'
          
        
      
        

          

            4
            

            

                    if value && value_desc
          
        
      
        

          

            4
            

            

                      desc += "\n#{value.to_s(2)} | #{value_desc}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            60
            

            

                  desc
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def mask(reg)
          
        
      
        

          

            30
            

            

                  m = 0
          
        
      
        

          

            30
            

            

                  reg.size.times do |i|
          
        
      
        

          

            464
            

            

                    unless reg[i].reset_val == :undefined
          
        
      
        

          

            464
            

            

                      m |= (1 << i)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            30
            

            

                  m
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def uvm?
          
        
      
        

          

            170
            

            

                  @format == :uvm
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def memory_maps
          
        
      
        

          

            4
            

            

                  { nil => {} }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def sub_blocks(domain_name)
          
        
      
        

          

            4
            

            

                  owner.all_sub_blocks.select do |sub_block|
          
        
      
        

          

            8
            

            

                    sub_block.owns_registers? &&
          
        
      
        

          

            6
            

            

                      (sub_block.domains[domain_name] || domain_name == :default)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def address_blocks
          
        
      
        

          

            4
            

            

                  domains = owner.register_domains
          
        
      
        

          

            4
            

            

                  domains = { default: {} } if domains.empty?
          
        
      
        

          

            4
            

            

                  domains.each do |domain_name, domain|
          
        
      
        

          

            4
            

            

                    if owner.owns_registers?
          
        
      
        

          

            4
            

            

                      yield domain_name, domain, owner
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            4
            

            

                    sub_blocks(domain_name).each do |sub_block|
          
        
      
        

          

            6
            

            

                      yield domain_name, domain, sub_block
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def address_block_name(domain_name, sub_block)
          
        
      
        

          

            6
            

            

                  if domain_name == :default
          
        
      
        

          

            6
            

            

                    sub_block.name.to_s
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            
            

            

                    "#{domain_name}_#{sub_block.name}"
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def width(sub_block)
          
        
      
        

          

            20
            

            

                  sub_block.try(:width) || 32
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def range(sub_block)
          
        
      
        

          

            10
            

            

                  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
          
        
      
        

          

            10
            

            

                    max_address_reg_size = sub_block.max_address_reg_size || sub_block.regs.first[1].size
          
        
      
        

          

            10
            

            

                    (sub_block.max_reg_address + (max_address_reg_size / 8))
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            10
            

            

                  width_in_bytes = width(sub_block) / 8
          
        
      
        

          

            10
            

            

                  if range % width_in_bytes != 0
          
        
      
        

          

            4
            

            

                    range += (width_in_bytes - (range % width_in_bytes))
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            10
            

            

                  range
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            1
            

            

              class Ralf
          
        
      
        

          

            
            

            

                # Returns the object that included the CrossOrigen module
          
        
      
        

          

            1
            

            

                attr_reader :owner
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(owner)
          
        
      
        

          

            1
            

            

                  @owner = owner
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns a string representing the owner object in RALF format
          
        
      
        

          

            1
            

            

                def owner_to_ralf(options = {})
          
        
      
        

          

            1
            

            

                  Origen.compile("#{Origen.root!}/templates/ralf/default.ralf.erb", options.merge(scope: owner))
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'kramdown'
          
        
      
        

          

            1
            

            

            require 'sanitize'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module CrossOrigen
          
        
      
        

          

            
            

            

              # This is the base class of all doc formats that are
          
        
      
        

          

            
            

            

              # XML based
          
        
      
        

          

            1
            

            

              class XMLDoc
          
        
      
        

          

            1
            

            

                CreationInfo = Struct.new(:author, :date, :revision, :source)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                ImportInfo = Struct.new(:name, :date)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                attr_accessor :creation_info, :import_info
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # These (in many cases illegal) tags will be forced to their valid equivalents
          
        
      
        

          

            
            

            

                # These will be executed in the defined order, so for later xfrms you can for example
          
        
      
        

          

            
            

            

                # assume that all 'rows' have already been converted to 'tr'
          
        
      
        

          

            
            

            

                # valid equivalents
          
        
      
        

          

            
            

            

                HTML_TRANSFORMS = {
          
        
      
        

          

            1
            

            

                  'table/title'  => 'caption',
          
        
      
        

          

            
            

            

                  'table//row'   => 'tr',
          
        
      
        

          

            
            

            

                  'thead//entry' => 'th',
          
        
      
        

          

            
            

            

                  'table//entry' => 'td',
          
        
      
        

          

            
            

            

                  'td/p'         => 'span',
          
        
      
        

          

            
            

            

                  'th/p'         => 'span'
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # This can be used to perform additional by-node transformation if required, normally
          
        
      
        

          

            
            

            

                # this should be used if transform of a node attribute is required
          
        
      
        

          

            1
            

            

                HTML_TRANSFORMER = lambda do |env|
          
        
      
        

          

            449
            

            

                  if env[:node_name] == 'td' || env[:node_name] == 'th'
          
        
      
        

          

            50
            

            

                    if env[:node].attr('nameend')
          
        
      
        

          

            1
            

            

                      first = env[:node].attr('namest').sub('col', '').to_i
          
        
      
        

          

            1
            

            

                      last = env[:node].attr('nameend').sub('col', '').to_i
          
        
      
        

          

            1
            

            

                      env[:node].set_attribute('colspan', (last - first + 1).to_s)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Defines the rules for sanitization of any HTML strings that will be converted
          
        
      
        

          

            
            

            

                # to markdown for representation within Origen
          
        
      
        

          

            
            

            

                HTML_SANITIZATION_CONFIG = {
          
        
      
        

          

            
            

            

                  # Only these tags will be allowed through, everything else will be stripped
          
        
      
        

          

            
            

            

                  # Note that this is applied after the transforms listed above
          
        
      
        

          

            1
            

            

                  elements:     %w(b em i strong u p ul ol li table tr td th tbody thead),
          
        
      
        

          

            
            

            

                  attributes:   {
          
        
      
        

          

            
            

            

                    'td' => ['colspan'],
          
        
      
        

          

            
            

            

                    'th' => ['colspan']
          
        
      
        

          

            
            

            

                  },
          
        
      
        

          

            
            

            

                  # Not planning to allow any of these right now, but keeping around
          
        
      
        

          

            
            

            

                  # as an example of how to do so
          
        
      
        

          

            
            

            

                  #:protocols => {
          
        
      
        

          

            
            

            

                  #  'a' => {'href' => ['http', 'https', 'mailto']}
          
        
      
        

          

            
            

            

                  # }
          
        
      
        

          

            
            

            

                  transformers: HTML_TRANSFORMER
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Returns the object that included the CrossOrigen module
          
        
      
        

          

            1
            

            

                attr_reader :owner
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(owner)
          
        
      
        

          

            21
            

            

                  @owner = owner
          
        
      
        

          

            21
            

            

                  @creation_info = CreationInfo.new
          
        
      
        

          

            21
            

            

                  @import_info = ImportInfo.new
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Tries the given methods on the owner and returns the first one to return a value,
          
        
      
        

          

            
            

            

                # ultimately returns nil if no value is found.
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # To test an object other than the owner pass it as the first argument.
          
        
      
        

          

            1
            

            

                def try(*methods)
          
        
      
        

          

            200
            

            

                  if methods.first.is_a?(Symbol)
          
        
      
        

          

            8
            

            

                    obj = owner
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            192
            

            

                    obj = methods.shift
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            200
            

            

                  methods.each do |method|
          
        
      
        

          

            562
            

            

                    if obj.respond_to?(method)
          
        
      
        

          

            200
            

            

                      val = obj.send(method)
          
        
      
        

          

            200
            

            

                      return val if val
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # This returns the doc wrapped by a Nokogiri doc
          
        
      
        

          

            1
            

            

                def doc(path, options = {})
          
        
      
        

          

            4
            

            

                  require 'nokogiri'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            4
            

            

                  File.open(path) do |f|
          
        
      
        

          

            4
            

            

                    yield Nokogiri::XML(f)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def extract(element, path, options = {})
          
        
      
        

          

            
            

            

                  options = {
          
        
      
        

          

            1154
            

            

                    format:   :string,
          
        
      
        

          

            
            

            

                    hex:      false,
          
        
      
        

          

            
            

            

                    default:  nil,
          
        
      
        

          

            
            

            

                    downcase: false,
          
        
      
        

          

            
            

            

                    return:   :text,
          
        
      
        

          

            
            

            

                    # A value or array or values which are considered to be nil, if this is the value
          
        
      
        

          

            
            

            

                    # to be returned then nil will be returned instead
          
        
      
        

          

            
            

            

                    nil_on:   false
          
        
      
        

          

            
            

            

                  }.merge(options)
          
        
      
        

          

            1154
            

            

                  node = element.at_xpath(path)
          
        
      
        

          

            1154
            

            

                  if node
          
        
      
        

          

            752
            

            

                    if options[:format] == :string
          
        
      
        

          

            586
            

            

                      str = node.send(options[:return]).strip
          
        
      
        

          

            586
            

            

                      str = str.downcase if options[:downcase]
          
        
      
        

          

            586
            

            

                      if options[:nil_on] && [options[:nil_on]].flatten.include?(str)
          
        
      
        

          

            
            

            

                        nil
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            586
            

            

                        str
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            166
            

            

                    elsif options[:format] == :integer
          
        
      
        

          

            166
            

            

                      val = node.send(options[:return])
          
        
      
        

          

            166
            

            

                      if val =~ /^0x(.*)/
          
        
      
        

          

            106
            

            

                        Regexp.last_match[1].to_i(16)
          
        
      
        

          

            60
            

            

                      elsif options[:hex]
          
        
      
        

          

            
            

            

                        val.to_i(16)
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            60
            

            

                        val.to_i(10)
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            
            

            

                      fail "Unknown format: #{options[:format]}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            402
            

            

                    options[:default]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Freescale register descriptions are like the wild west, need to do some pre-screening
          
        
      
        

          

            
            

            

                # to approach valid HTML before handing off to other off the shelf sanitizers
          
        
      
        

          

            1
            

            

                def pre_sanitize(html)
          
        
      
        

          

            4
            

            

                  html = Nokogiri::HTML.fragment(html)
          
        
      
        

          

            4
            

            

                  HTML_TRANSFORMS.each do |orig, new|
          
        
      
        

          

            108
            

            

                    html.xpath(".//#{orig}").each { |node| node.name = new }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            4
            

            

                  html.to_html
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Does its best to convert the given html fragment to markdown
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # The final markdown may still contain some HTML tags, but any weird
          
        
      
        

          

            
            

            

                # markup which may break a future markdown -> html conversion will
          
        
      
        

          

            
            

            

                # be removed
          
        
      
        

          

            1
            

            

                def to_markdown(html, _options = {})
          
        
      
        

          

            4
            

            

                  cleaned = html.scrub
          
        
      
        

          

            4
            

            

                  cleaned = pre_sanitize(cleaned)
          
        
      
        

          

            4
            

            

                  cleaned = Sanitize.fragment(cleaned, HTML_SANITIZATION_CONFIG)
          
        
      
        

          

            4
            

            

                  Kramdown::Document.new(cleaned, input: :html).to_kramdown.strip
          
        
      
        

          

            
            

            

                rescue
          
        
      
        

          

            
            

            

                  'The description could not be imported, the most likely cause of this is that it contained illegal HTML markup'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Convert the given markdown string to HTML
          
        
      
        

          

            1
            

            

                def to_html(string, _options = {})
          
        
      
        

          

            
            

            

                  # Escape any " that are not already escaped
          
        
      
        

          

            2
            

            

                  string.gsub!(/([^\\])"/, '\1\"')
          
        
      
        

          

            
            

            

                  # Escape any ' that are not already escaped
          
        
      
        

          

            2
            

            

                  string.gsub!(/([^\\])'/, %q(\1\\\'))
          
        
      
        

          

            2
            

            

                  html = Kramdown::Document.new(string, input: :kramdown).to_html
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # fetch an XML snippet passed and extract and format the data
          
        
      
        

          

            1
            

            

                def fetch(xml, options = {})
          
        
      
        

          

            
            

            

                  options = {
          
        
      
        

          

            426
            

            

                    type:          String,
          
        
      
        

          

            
            

            

                    downcase:      false,
          
        
      
        

          

            
            

            

                    symbolize:     false,
          
        
      
        

          

            
            

            

                    strip:         false,
          
        
      
        

          

            
            

            

                    squeeze:       false,
          
        
      
        

          

            
            

            

                    squeeze_lines: false,
          
        
      
        

          

            
            

            

                    rm_specials:   false,
          
        
      
        

          

            
            

            

                    whitespace:    false,
          
        
      
        

          

            
            

            

                    get_text:      false,
          
        
      
        

          

            
            

            

                    to_i:          false,
          
        
      
        

          

            
            

            

                    to_html:       false,
          
        
      
        

          

            
            

            

                    to_bool:       false,
          
        
      
        

          

            
            

            

                    children:      false,
          
        
      
        

          

            
            

            

                    to_dec:        false,
          
        
      
        

          

            
            

            

                    to_f:          false,
          
        
      
        

          

            
            

            

                    underscore:    false
          
        
      
        

          

            
            

            

                  }.update(options)
          
        
      
        

          

            426
            

            

                  options[:symbolize] = options[:to_sym] if options[:to_sym]
          
        
      
        

          

            
            

            

                  # Check for incompatible options
          
        
      
        

          

            426
            

            

                  xml_orig = xml
          
        
      
        

          

            426
            

            

                  numeric_methods = [:to_i, :to_f, :to_dec]
          
        
      
        

          

            426
            

            

                  if options[:get_text] == true && options[:to_html] == true
          
        
      
        

          

            
            

            

                    fail 'Cannot use :get_text and :to_html options at the same time, exiting...'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            426
            

            

                  if options[:symbolize] == true
          
        
      
        

          

            272
            

            

                    fail 'Cannot convert to a number of any type and symbolize at the same time' if numeric_methods.reject { |arg| options[arg] == true }.size < 3
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1704
            

            

                  fail 'Cannot select multiple numeric conversion args at the same time' if numeric_methods.reject { |arg| options[arg] == true }.size < 2
          
        
      
        

          

            426
            

            

                  if xml.nil?
          
        
      
        

          

            33
            

            

                    Origen.log.debug 'XML data is nil!'
          
        
      
        

          

            33
            

            

                    return nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            393
            

            

                  xml = xml.text if options[:get_text] == true
          
        
      
        

          

            
            

            

                  # Sometimes XML snippets get sent as nodes or as Strings
          
        
      
        

          

            
            

            

                  # Must skip this code if a String as it is designed to change
          
        
      
        

          

            
            

            

                  # the XML node into a string
          
        
      
        

          

            393
            

            

                  unless xml.is_a? String
          
        
      
        

          

            
            

            

                    if options[:to_html] == true
          
        
      
        

          

            
            

            

                      if xml.children
          
        
      
        

          

            
            

            

                        # If there are children to this XMl node then grab the content there
          
        
      
        

          

            
            

            

                        if xml.children.empty? || options[:children] == false
          
        
      
        

          

            
            

            

                          xml = xml.to_html
          
        
      
        

          

            
            

            

                        else
          
        
      
        

          

            
            

            

                          xml = xml.children.to_html
          
        
      
        

          

            
            

            

                        end
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            393
            

            

                  unless xml.is_a? options[:type]
          
        
      
        

          

            
            

            

                    Origen.log.debug "XML data is not of correct type '#{options[:type]}'"
          
        
      
        

          

            
            

            

                    Origen.log.debug "xml is \n#{xml}"
          
        
      
        

          

            
            

            

                    return nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            393
            

            

                  if options[:type] == String
          
        
      
        

          

            393
            

            

                    if xml.match(/\s+/) && options[:whitespace] == false
          
        
      
        

          

            
            

            

                      Origen.log.debug "XML data '#{xml}' cannot have white space"
          
        
      
        

          

            
            

            

                      return nil
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            393
            

            

                    xml.downcase! if options[:downcase] == true
          
        
      
        

          

            393
            

            

                    xml = xml.underscore if options[:underscore] == true
          
        
      
        

          

            393
            

            

                    xml.strip! if options[:strip] == true
          
        
      
        

          

            393
            

            

                    xml.squeeze!(' ') if options[:squeeze] == true
          
        
      
        

          

            393
            

            

                    xml = xml.squeeze_lines if options[:squeeze_lines] == true
          
        
      
        

          

            393
            

            

                    xml.gsub!(/[^0-9A-Za-z]/, '_') if options[:rm_specials] == true
          
        
      
        

          

            393
            

            

                    if options[:symbolize] == true
          
        
      
        

          

            68
            

            

                      return xml.to_sym
          
        
      
        

          

            325
            

            

                    elsif options[:to_i] == true
          
        
      
        

          

            126
            

            

                      return xml.to_i
          
        
      
        

          

            199
            

            

                    elsif options[:to_dec] == true
          
        
      
        

          

            16
            

            

                      return xml.to_dec
          
        
      
        

          

            183
            

            

                    elsif options[:to_f] == true
          
        
      
        

          

            
            

            

                      return xml.to_f
          
        
      
        

          

            183
            

            

                    elsif [true, false].include?(xml.to_bool) && options[:to_bool] == true
          
        
      
        

          

            
            

            

                      # If the string can convert to Boolean then return TrueClass or FalseClass
          
        
      
        

          

            
            

            

                      return xml.to_bool
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            183
            

            

                      return xml
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            
            

            

                    # No real examples yet of non-string content
          
        
      
        

          

            
            

            

                    return xml
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            module CrossOrigenDev
          
        
      
        

          

            
            

            

              # Simple DUT class used for testing
          
        
      
        

          

            1
            

            

              class DUT
          
        
      
        

          

            1
            

            

                include Origen::TopLevel
          
        
      
        

          

            1
            

            

                include CrossOrigen
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize
          
        
      
        

          

            15
            

            

                  @path = :hidden
          
        
      
        

          

            15
            

            

                  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
          
        
      
        

          

            15
            

            

                  reg :dut_top_level_reg, 0x0, size: 32, bit_order: :msb0, lau: 8 do
          
        
      
        

          

            15
            

            

                    bit 15, :pls_work, reset: 1, access: :rw
          
        
      
        

          

            15
            

            

                    bit 14, :second_bit, reset: 0, access: :rw
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  # Register defined solely to test out the top level register export
          
        
      
        

          

            15
            

            

                  reg :dut_top_level_reg_number_two, 0x10, size: 32, bit_order: :lsb0, lau: 16 do
          
        
      
        

          

            15
            

            

                    bit 0, :pls_work, reset: 0, access: :ro
          
        
      
        

          

            15
            

            

                    bit 1, :second_bit, reset: 1, access: :rw
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                  # Import some data from IP-XACT
          
        
      
        

          

            15
            

            

                  cr_import(path: "#{Origen.root}/imports/ipxact.xml")
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Import Spirit 1.4 version of ATX
          
        
      
        

          

            1
            

            

                def add_atx2
          
        
      
        

          

            1
            

            

                  sub_block :atx2, class_name: 'ATX2', base_address: 0x6000_0000
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class ATX2
          
        
      
        

          

            1
            

            

                  include Origen::Model
          
        
      
        

          

            1
            

            

                  include CrossOrigen
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize
          
        
      
        

          

            1
            

            

                    cr_import(path: "#{Origen.root}/approved/ip_xact_sub_block.xml", refresh: true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Import 1685-2009 version of ATX
          
        
      
        

          

            1
            

            

                def add_atx3
          
        
      
        

          

            1
            

            

                  sub_block :atx3, class_name: 'ATX3', base_address: 0x7000_0000
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class ATX3
          
        
      
        

          

            1
            

            

                  include Origen::Model
          
        
      
        

          

            1
            

            

                  include CrossOrigen
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize
          
        
      
        

          

            1
            

            

                    cr_import(path: "#{Origen.root}/approved/ip_xact_sub_block_1685.xml", refresh: true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                class D_IP_ANA_TEST_ANNEX_SYN # rubocop:disable ClassAndModuleCamelCase
          
        
      
        

          

            1
            

            

                  include Origen::Model
          
        
      
        

          

            1
            

            

                  include CrossOrigen
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def initialize
          
        
      
        

          

            
            

            

                    # A manually defined set of registers for testing the conversion of any specific attributes
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # ** MPU Clock Divider Register **
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # The MCLKDIV register is used to divide down the frequency of the OSCCLK 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 TIMER module to control the duration of operations.
          
        
      
        

          

            
            

            

                    # This is a test of potentially problematic characters ' " \' \" < >
          
        
      
        

          

            15
            

            

                    reg :mclkdiv, 0x0, size: 16, bit_order: 'decrement' do
          
        
      
        

          

            
            

            

                      # **Oscillator (Hi)** - Clock source selection. (Note that in addition to this firmware-controlled bit, the
          
        
      
        

          

            
            

            

                      # clock source is also dependent on test and power control discretes).
          
        
      
        

          

            
            

            

                      #
          
        
      
        

          

            
            

            

                      # 0 | Clock is the externally supplied bus clock bus_clk
          
        
      
        

          

            
            

            

                      # 1 | Clock is the internal oscillator from the hardblock
          
        
      
        

          

            15
            

            

                      bit 15, :osch, reset: 1, access: :rw
          
        
      
        

          

            
            

            

                      # **Divider Value**
          
        
      
        

          

            
            

            

                      #
          
        
      
        

          

            
            

            

                      # Used to set clock divider value and test multi-bit import in CrossOrigen
          
        
      
        

          

            15
            

            

                      bits 3..0, :div
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # **Access Type Test Register**
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # This register tests the IP-XACT export of various bit access types, such as write-one-to-clear,
          
        
      
        

          

            
            

            

                    # read-only, etc.
          
        
      
        

          

            15
            

            

                    reg :access_types, 0x4, size: 32 do
          
        
      
        

          

            
            

            

                      # Test read-only access.
          
        
      
        

          

            15
            

            

                      bit 31, :readonly, access: :ro
          
        
      
        

          

            
            

            

                      # Test read-write access.
          
        
      
        

          

            15
            

            

                      bit 30, :readwrite, access: :rw
          
        
      
        

          

            
            

            

                      # Test read-clear access, where a read clears the value afterwards.
          
        
      
        

          

            15
            

            

                      bit 29, :readclear, access: :rc
          
        
      
        

          

            
            

            

                      # Test read-set access, where a read sets the bit afterwards.
          
        
      
        

          

            15
            

            

                      bit 28, :readset, access: :rs
          
        
      
        

          

            
            

            

                      # Test writable, clear-on-read access, etc...
          
        
      
        

          

            15
            

            

                      bit 27, :writablereadclear, access: :wrc
          
        
      
        

          

            15
            

            

                      bit 26, :writablereadset, access: :wrs
          
        
      
        

          

            15
            

            

                      bit 25, :writeclear, access: :wc
          
        
      
        

          

            15
            

            

                      bit 24, :writeset, access: :ws
          
        
      
        

          

            15
            

            

                      bit 23, :writesetreadclear, access: :wsrc
          
        
      
        

          

            15
            

            

                      bit 22, :writeclearreadset, access: :wcrs
          
        
      
        

          

            15
            

            

                      bit 21, :write1toclear, access: :w1c
          
        
      
        

          

            15
            

            

                      bit 20, :write1toset, access: :w1s
          
        
      
        

          

            15
            

            

                      bit 19, :write1totoggle, access: :w1t
          
        
      
        

          

            15
            

            

                      bit 18, :write0toclear, access: :w0c
          
        
      
        

          

            15
            

            

                      bit 17, :write0toset, access: :w0s
          
        
      
        

          

            15
            

            

                      bit 16, :write0totoggle, access: :w0t
          
        
      
        

          

            15
            

            

                      bit 15, :write1tosetreadclear, access: :w1src
          
        
      
        

          

            15
            

            

                      bit 14, :write1toclearreadset, access: :w1crs
          
        
      
        

          

            15
            

            

                      bit 13, :write0tosetreadclear, access: :w0src
          
        
      
        

          

            15
            

            

                      bit 12, :write0toclearreadset, access: :w0crs
          
        
      
        

          

            15
            

            

                      bit 11, :writeonly, access: :wo
          
        
      
        

          

            15
            

            

                      bit 10, :writeonlyclear, access: :woc
          
        
      
        

          

            15
            

            

                      bit 9, :writeonlyreadzero, access: :worz
          
        
      
        

          

            15
            

            

                      bit 8, :writeonlyset, access: :wos
          
        
      
        

          

            15
            

            

                      bit 7, :writeonce, access: :w1
          
        
      
        

          

            15
            

            

                      bit 6, :writeonlyonce, access: :wo1
          
        
      
        

          

            15
            

            

                      bit 5, :readwritenocheck, access: :dc
          
        
      
        

          

            15
            

            

                      bit 4, :readonlyclearafter, access: :rowz
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end