origen 0.34.3 → 0.52.0

data/lib/origen/model/exporter.rb

@@ -1,6 +1,16 @@
 module Origen
   module Model
     module Exporter
+      # Export the model
+      #
+      # Options defaults:
+      #   include_pins:       true
+      #   include_registers:  true
+      #   include_sub_blocks: true
+      #   include_timestamp:  true
+      #   rm_rb_only:         nil     # delete only .rb files, default is rm -rf * Origen.root/vendor/lib/models/name
+      #
+      # Use the rm_rb_only option if the export dir is under revision control and the dir contains revision control metadata
       def export(name, options = {})
         options = {
           include_pins:       true,
@@ -14,7 +24,13 @@ module Origen
         file = options[:file_path] || export_path(name, options)
         dir = options[:dir_path] || export_dir(options)
         path_to_file = Pathname.new(File.join(dir, file))
-        FileUtils.rm_rf(path_to_file.sub_ext('').to_s) if File.exist?(path_to_file.sub_ext('').to_s)
+        if File.exist?(path_to_file.sub_ext('').to_s)
+          if options[:rm_rb_only]
+            Dir.glob(path_to_file.sub_ext('').to_s + '/**/*.rb').each { |f| FileUtils.rm_f(f) }
+          else
+            FileUtils.rm_rf(path_to_file.sub_ext('').to_s)
+          end
+        end
         FileUtils.rm_rf(path_to_file.to_s) if File.exist?(path_to_file.to_s)
         FileUtils.mkdir_p(path_to_file.dirname)
         File.open(path_to_file, 'w') do |f|
@@ -114,7 +130,7 @@ module Origen
                   attr_end_str = (attr == pin_pkg_meta.keys.last) ? ' }' : ', '
                   case attr_val
                   when String
-                    str << "'#{attr_val}'#{attr_end_str}"
+                    str << "\"#{attr_val.gsub('"', '\"')}\"#{attr_end_str}"
                   else
                     str << "#{attr_val}#{attr_end_str}"
                   end
@@ -177,6 +193,9 @@ module Origen
         if (d = pin.direction) != :io
           line << ", direction: :#{d}"
         end
+        if (t = pin.type)
+          line << ", type: :#{t}"
+        end
         pkg_meta = write_pin_packages(pin)
         line << ", #{pkg_meta}" unless pkg_meta == ''
         Array(options[:attributes]).each do |attr|
@@ -224,7 +243,7 @@ module Origen
         indent = ' ' * (options[:indent] || 0)
         file_path = File.join(Pathname.new(options[:file_path]).sub_ext(''), "#{id}.rb")
         dir_path = options[:dir_path]
-        line = indent + "model.sub_block :#{id}, file: '#{file_path}', dir: '#{dir_path}', lazy: true"
+        line = indent + "model.sub_block :#{id}, file: '#{file_path}', dir: \"#{dir_path.gsub(Origen.root.to_s, '#{Origen.root!}')}\", lazy: true"
         unless block.base_address == 0
           line << ", base_address: #{block.base_address.to_hex}"
         end
@@ -232,9 +251,9 @@ module Origen
           if value.is_a?(Symbol)
             line << ", #{key}: :#{value}"
           elsif value.is_a?(String)
-            line << ", #{key}: '#{value}'"
+            line << ", #{key}: \"#{value.gsub('"', '\"')}\""
           else
-            line << ", #{key}: #{value}"
+            line << ", #{key}: #{value}" unless value.nil?
           end
         end
         block.export(id, options.merge(file_path: file_path, dir_path: dir_path))
@@ -247,22 +266,29 @@ module Origen
         unless reg.description.empty?
           reg.description.each { |l| lines << indent + "# #{l}" }
         end
-        lines << indent + "model.add_reg :#{id}, #{reg.offset.to_hex}, size: #{reg.size} do |reg|"
+        lines << indent + "model.add_reg :#{id}, #{reg.offset.to_hex}, size: #{reg.size} #{reg.bit_order == :msb0 ? ', bit_order: :msb0' : ''}#{build_reg_meta(reg)} do |reg|"
         indent = ' ' * ((options[:indent] || 0) + 2)
         reg.named_bits.each do |name, bits|
           unless bits.description.empty?
             bits.description.each { |l| lines << indent + "# #{l}" }
           end
+          position = reg.bit_order == :msb0 ? (reg.size - bits.position - 1) : bits.position
           if bits.size == 1
-            line = indent + "reg.bit #{bits.position}, :#{name}"
+            line = indent + "reg.bit #{position}, :#{name}"
           else
-            line = indent + "reg.bit #{bits.position + bits.size - 1}..#{bits.position}, :#{name}"
+            if reg.bit_order == :msb0
+              line = indent + "reg.bit #{position - bits.size + 1}..#{position}, :#{name}"
+            else
+              line = indent + "reg.bit #{position + bits.size - 1}..#{position}, :#{name}"
+            end
           end
           unless bits.access == :rw
             line << ", access: :#{bits.access}"
           end
-          unless bits.reset_val == 0
-            line << ", reset: #{bits.reset_val.to_hex}"
+          if bits.reset_val.is_a?(Symbol)
+            line << ", reset: :#{bits.reset_val}"
+          else
+            line << ", reset: #{bits.reset_val.to_hex}" unless bits.reset_val == 0
           end
           lines << line
         end
@@ -270,6 +296,20 @@ module Origen
         lines << indent + 'end'
         lines.join("\n")
       end
+
+      def build_reg_meta(reg)
+        ret_str = ''
+        reg.meta.each do |key, value|
+          if value.is_a?(Symbol)
+            ret_str += ", #{key}: :#{value}"
+          elsif value.is_a?(String)
+            ret_str += ", #{key}: \"#{value.gsub('"', '\"')}\""
+          else
+            ret_str += ", #{key}: #{value}" unless value.nil?
+          end
+        end
+        ret_str
+      end
     end
   end
 end

data/lib/origen/model_initializer.rb

@@ -46,7 +46,10 @@ module Origen
         else
           x.send(:initialize, *args, &block)
         end
-        x.send(:_initialized) if x.respond_to?(:is_an_origen_model?)
+        if x.respond_to?(:is_an_origen_model?)
+          x.send(:_initialized)
+          Origen::Loader.load_block(x)
+        end
         if x.respond_to?(:register_callback_listener)
           Origen.after_app_loaded do |app|
             x.register_callback_listener
@@ -55,6 +58,7 @@ module Origen
         # Do this before wrapping, otherwise the respond to method in the controller will
         # be looking for the model to be instantiated when it is not fully done yet
         is_top_level = x.respond_to?(:includes_origen_top_level?)
+
         if x.respond_to?(:wrap_in_controller)
           x = x.wrap_in_controller
         end

data/lib/origen/operating_systems.rb

@@ -22,6 +22,10 @@ module Origen
       !windows?
     end
   end
+
+  # Blow this cache whenever this file is re-loaded
+  @operating_systems = nil
+
   def self.os
     @operating_systems ||= OperatingSystems.new
   end

data/lib/origen/parameters.rb

@@ -1,4 +1,5 @@
 require 'active_support/concern'
+require 'set'
 module Origen
   module Parameters
     extend ActiveSupport::Concern
@@ -8,6 +9,75 @@ module Origen
 
     attr_accessor :current
 
+    # @api private
+    #
+    # Any define_params blocks contained within the given block will be allowed to be re-opened later
+    # in the block to override existing parameter settings or to add new ones.
+    #
+    # This is not allowed normally since already-defined child parameter sets could have referenced the
+    # original parameter and they would not reflect the final value after re-opening the parent parameter
+    # set.
+    #
+    # By defining the parameters within this block, Origen will keep track of relationships between parameter
+    # sets and any time a parent is changed the definitions of existing children will be re-executed to ensure
+    # that they reflect the new values.
+    #
+    # This is initially intended to support the concept of a app/parameters/application.rb being
+    # used to define baseline parameter sets, and then target-specific files can then override them.
+    def self.transaction
+      start_transaction
+      yield
+      stop_transaction
+    end
+
+    # @api private
+    def self.start_transaction
+      @transaction_data = {}
+      @transaction_open = true
+      @transaction_counter ||= 0
+      @transaction_counter += 1
+    end
+
+    # @api private
+    def self.stop_transaction
+      @transaction_counter -= 1
+      if @transaction_counter == 0
+        # Now finalize (freeze) all parameter sets we have just defined, this was deferred at define time due
+        # to running within a transaction
+        @transaction_data.each do |model, parameter_sets|
+          parameter_sets.keys.each do |name|
+            model._parameter_sets[name].finalize
+          end
+        end
+        @transaction_data = nil
+        @transaction_open = false
+      end
+    end
+
+    # @api private
+    def self.transaction_data
+      @transaction_data
+    end
+
+    # @api private
+    def self.transaction_open
+      @transaction_open
+    end
+
+    # @api private
+    def self.transaction_redefine
+      @transaction_redefine
+    end
+
+    # @api private
+    def self.redefine(model, name)
+      @transaction_redefine = true
+      model._parameter_sets.delete(name)
+      @transaction_data[model][name][:definitions].each { |options, block| model.define_params(name, options, &block) }
+      @transaction_data[model][name][:children].each { |model, name| redefine(model, name) }
+      @transaction_redefine = false
+    end
+
     module ClassMethods
       def parameters_context(obj = nil)
         if obj
@@ -25,19 +95,41 @@ module Origen
       end
     end
 
+    # @api private
+    def define_params_transaction
+      Origen::Parameters.transaction_data
+    end
+
     def define_params(name, options = {}, &block)
-      if _parameter_sets[name]
-        fail 'Parameter sets cannot be re-opened once originally defined!'
+      name = name.to_sym
+      if _parameter_sets[name] && !Origen::Parameters.transaction_open
+        fail "Parameter set '#{name}' cannot be re-opened once originally defined!"
       else
-        _parameter_sets[name] = Set.new(top_level: true, owner: self)
+        if Origen::Parameters.transaction_open && !Origen::Parameters.transaction_redefine
+          define_params_transaction[self] ||= {}
+          define_params_transaction[self][name] ||= { children: ::Set[], definitions: [] }
+          define_params_transaction[self][name][:definitions] << [options.dup, block]
+          redefine_children = define_params_transaction[self][name][:children] if _parameter_sets[name]
+        end
+        if _parameter_sets[name]
+          defaults_already_set = true
+        else
+          _parameter_sets[name] = Origen::Parameters::Set.new(top_level: true, owner: self)
+        end
         if options[:inherit]
           kontext = _validate_parameter_set_name(options[:inherit])
           parent = kontext[:obj]._parameter_sets[kontext[:context]]
-          _parameter_sets[name].copy_defaults_from(parent)
+          if Origen::Parameters.transaction_open && !Origen::Parameters.transaction_redefine
+            define_params_transaction[kontext[:obj]][kontext[:context]][:children] << [self, name]
+          end
+          _parameter_sets[name].copy_defaults_from(parent) unless defaults_already_set
           _parameter_sets[name].define(parent, &block)
         else
           _parameter_sets[name].define(&block)
         end
+        if redefine_children
+          redefine_children.each { |model, set_name| Origen::Parameters.redefine(model, set_name) }
+        end
       end
     end
     alias_method :define_parameters, :define_params

data/lib/origen/parameters/set.rb

@@ -21,7 +21,7 @@ module Origen
         @defining = true
         yield self, parent
         @defining = false
-        finalize
+        finalize unless Origen::Parameters.transaction_open
       end
 
       # Returns the current parameter context
@@ -60,10 +60,10 @@ module Origen
           if args.length != 0
             super
           else
-            val = self[method]
-            if !val
+            if !key?(method)
               super
             else
+              val = self[method]
               if val.is_a?(Set)
                 val
               else
@@ -114,6 +114,7 @@ module Origen
       end
 
       def defining?
+        return true if Origen::Parameters.transaction_open
         if top_level?
           @defining
         else

data/lib/origen/pins.rb

@@ -229,21 +229,23 @@ module Origen
 
         rtl_name = options[:rtl_name]
         force = options[:force]
+        offset = options.delete(:offset) || 0
         options.delete(:size).times do |i|
-          options[:name] = "#{id}#{i}".to_sym
-          options[:rtl_name] = "#{rtl_name}#{i}".to_sym if rtl_name
-          options[:force] = force[i] if force
+          pin_index = offset + i
+          options[:name] = "#{id}#{pin_index}".to_sym
+          options[:rtl_name] = "#{rtl_name}#{pin_index}".to_sym if rtl_name
+          options[:force] = force[pin_index] if force
 
           if power_pin
-            group[i] = PowerPin.new(i, self, options)
+            group[i] = PowerPin.new(pin_index, self, options)
           elsif ground_pin
-            group[i] = GroundPin.new(i, self, options)
+            group[i] = GroundPin.new(pin_index, self, options)
           elsif virtual_pin
-            group[i] = VirtualPin.new(i, self, options)
+            group[i] = VirtualPin.new(pin_index, self, options)
           elsif other_pin
-            group[i] = OtherPin.new(i, self, options)
+            group[i] = OtherPin.new(pin_index, self, options)
           else
-            group[i] = Pin.new(i, self, options)
+            group[i] = Pin.new(pin_index, self, options)
           end
           group[i].invalidate_group_cache
         end

data/lib/origen/pins/pin.rb

@@ -56,6 +56,14 @@ module Origen
       attr_accessor :description
       attr_accessor :notes
 
+      # Returns a hash containing any meta data associated with the current pin state
+      #
+      #   my_pin.read!(1, meta: { position: 10 })
+      #   my_pin.state_meta    # => { position: 10 }
+      #   my_pin.dont_care
+      #   my_pin.state_meta    # => {}
+      attr_reader :state_meta
+
       # Should be instantiated through the HasPins macros
       def initialize(id, owner, options = {}) # :nodoc:
         options = {
@@ -89,6 +97,7 @@ module Origen
         @clock = nil
         @meta = options[:meta] || {}
         @dib_meta = options[:dib_meta] || {}
+        @state_meta = {}
         @_saved_state = []
         @_saved_value = []
         @_saved_suspend = []
@@ -638,6 +647,11 @@ module Origen
         @repeat_previous
       end
 
+      def set_state_with_options(state, options = {})
+        @state_meta = options[:meta] || {}
+        set_state(state)
+      end
+
       def set_state(state)
         invalidate_vector_cache
         @repeat_previous = false
@@ -690,76 +704,77 @@ module Origen
 
       def state=(value)
         invalidate_vector_cache
+        @state_meta = {}
         @state = value
       end
 
       # Set the pin to drive a 1 on future cycles
-      def drive_hi
-        set_state(:drive)
+      def drive_hi(options = {})
+        set_state_with_options(:drive, options)
         set_value(1)
       end
       alias_method :write_hi, :drive_hi
 
-      def drive_hi!
-        drive_hi
+      def drive_hi!(options = {})
+        drive_hi(options)
         cycle
       end
       alias_method :write_hi!, :drive_hi!
 
       # Set the pin to drive a high voltage on future cycles (if the tester supports it).
       # For example on a J750 high-voltage channel the pin state would be set to "2"
-      def drive_very_hi
-        set_state(:drive_very_hi)
+      def drive_very_hi(options = {})
+        set_state_with_options(:drive_very_hi, options)
         set_value(1)
       end
 
-      def drive_very_hi!
-        drive_very_hi
+      def drive_very_hi!(options = {})
+        drive_very_hi(options)
         cycle
       end
 
       # Set the pin to drive a 0 on future cycles
-      def drive_lo
-        set_state(:drive)
+      def drive_lo(options = {})
+        set_state_with_options(:drive, options)
         set_value(0)
       end
       alias_method :write_lo, :drive_lo
 
-      def drive_lo!
-        drive_lo
+      def drive_lo!(options = {})
+        drive_lo(options)
         cycle
       end
       alias_method :write_lo!, :drive_lo!
 
-      def drive_mem
-        set_state(:drive_mem)
+      def drive_mem(options = {})
+        set_state_with_options(:drive_mem, options)
       end
 
-      def drive_mem!
-        drive_mem
+      def drive_mem!(options = {})
+        drive_mem(options)
         cycle
       end
 
-      def expect_mem
-        set_state(:expect_mem)
+      def expect_mem(options = {})
+        set_state_with_options(:expect_mem, options)
       end
 
-      def expect_mem!
-        expect_mem
+      def expect_mem!(options = {})
+        expect_mem(options)
         cycle
       end
 
       # Set the pin to expect a 1 on future cycles
-      def assert_hi(_options = {})
-        set_state(:compare)
+      def assert_hi(options = {})
+        set_state_with_options(:compare, options)
         set_value(1)
       end
       alias_method :expect_hi, :assert_hi
       alias_method :compare_hi, :assert_hi
       alias_method :read_hi, :assert_hi
 
-      def assert_hi!
-        assert_hi
+      def assert_hi!(options = {})
+        assert_hi(options)
         cycle
       end
       alias_method :expect_hi!, :assert_hi!
@@ -767,8 +782,8 @@ module Origen
       alias_method :read_hi!, :assert_hi!
 
       # Set the pin to expect a 0 on future cycles
-      def assert_lo(_options = {})
-        set_state(:compare)
+      def assert_lo(options = {})
+        set_state_with_options(:compare, options)
         set_value(0)
         # Planning to add the active load logic to the tester instead...
         # options = { :active => false    #if active true means to take tester active load capability into account
@@ -783,8 +798,8 @@ module Origen
       alias_method :compare_lo, :assert_lo
       alias_method :read_lo, :assert_lo
 
-      def assert_lo!
-        assert_lo
+      def assert_lo!(options = {})
+        assert_lo(options)
         cycle
       end
       alias_method :expect_lo!, :assert_lo!
@@ -792,12 +807,12 @@ module Origen
       alias_method :read_lo!, :assert_lo!
 
       # Set the pin to X on future cycles
-      def dont_care
-        set_state(:dont_care)
+      def dont_care(options = {})
+        set_state_with_options(:dont_care, options)
       end
 
-      def dont_care!
-        dont_care
+      def dont_care!(options = {})
+        dont_care(options)
         cycle
       end
 
@@ -807,14 +822,14 @@ module Origen
       #   [0,1,1,0].each do |level|
       #       $pin(:d_in).drive(level)
       #   end
-      def drive(value)
-        set_state(:drive)
+      def drive(value, options = {})
+        set_state_with_options(:drive, options)
         set_value(value)
       end
       alias_method :write, :drive
 
-      def drive!(value)
-        drive(value)
+      def drive!(value, options = {})
+        drive(value, options)
         cycle
       end
       alias_method :write!, :drive!
@@ -825,8 +840,8 @@ module Origen
       #   [0,1,1,0].each do |level|
       #       $pin(:d_in).assert(level)
       #   end
-      def assert(value, _options = {})
-        set_state(:compare)
+      def assert(value, options = {})
+        set_state_with_options(:compare, options)
         set_value(value)
       end
       alias_method :compare, :assert
@@ -841,15 +856,15 @@ module Origen
       alias_method :expect!, :assert!
       alias_method :read!, :assert!
 
-      def assert_midband
-        set_state(:compare_midband)
+      def assert_midband(options = {})
+        set_state_with_options(:compare_midband, options)
       end
       alias_method :compare_midband, :assert_midband
       alias_method :expect_midband, :assert_midband
       alias_method :read_midband, :assert_midband
 
-      def assert_midband!
-        assert_midband
+      def assert_midband!(options = {})
+        assert_midband(options)
         cycle
       end
       alias_method :compare_midband!, :assert_midband!
@@ -909,14 +924,14 @@ module Origen
       end
 
       # Mark the (data) from the pin to be captured
-      def capture
-        set_state(:capture)
+      def capture(options = {})
+        set_state_with_options(:capture, options)
       end
       alias_method :store, :capture
 
       # Mark the (data) from the pin to be captured and trigger a cycle
-      def capture!
-        capture
+      def capture!(options = {})
+        capture(options)
         cycle
       end
       alias_method :store!, :capture!