origen_testers 0.41.0 → 0.42.0

data/lib/origen_testers/test/dummy_decompiler.rb

@@ -0,0 +1,106 @@
+module OrigenTesters
+  module Test
+    module Decompiler
+      module Dummy
+        extend OrigenTesters::Decompiler::API
+
+        class DummyTester
+          include VectorBasedTester
+        end
+
+        class PatternParsersMissing < OrigenTesters::Decompiler::Pattern
+        end
+
+        class PatternParseFrontmatterOnly < OrigenTesters::Decompiler::Pattern
+          def self.parse_frontmatter(raw_frontmatter:, context:)
+            OrigenTesters::Decompiler::Nodes::Frontmatter.new(context: context, pattern_header: [], comments: [])
+          end
+        end
+
+        class PatternParseFrontmatterPinlist < PatternParseFrontmatterOnly
+          def self.parse_pinlist(raw_pinlist:, context:)
+            OrigenTesters::Decompiler::Nodes::Pinlist.new(context: context, pattern_header: [], comments: [])
+          end
+        end
+
+        class PatternParseFrontmatterPinlistVector < PatternParseFrontmatterPinlist
+          def self.parse_vector(raw_vector:, context:)
+            OrigenTesters::Decompiler::Nodes::Vector.new(
+              context:    context,
+              repeat:     0,
+              timeset:    'timeset',
+              pin_states: %w(p1 p2),
+              comment:    'Comment'
+            )
+          end
+        end
+
+        class Pattern < PatternParseFrontmatterPinlistVector
+          @platform = 'dummy'
+          @platform_tokens = {
+            comment_start: '#',
+            test_token:    '!'
+          }
+
+          @splitter_config = {
+            pinlist_start: 0,
+            vectors_start: 0,
+            vectors_end:   -1
+          }
+
+          @parser_config = {
+            platform_grammar_name:        'OrigenTesters::Decompiler::BaseGrammar::VectorBased',
+            include_base_tokens_grammar:  true,
+            include_vector_based_grammar: true
+          }
+        end
+
+        class PatternIncomplete < PatternParseFrontmatterPinlistVector
+          @platform = 'dummy_incomplete'
+        end
+
+        class PatternNoParserConfig < PatternParseFrontmatterPinlistVector
+          @platform = 'pattern_no_parser_config'
+          @parser_config = nil
+          @splitter_config = {
+            pinlist_start: 0,
+            vectors_start: 0,
+            vectors_end:   -1
+          }
+        end
+
+        class PatternNoSplitterConfig < PatternParseFrontmatterPinlistVector
+          @platform = 'pattern_no_splitter_config'
+          @parser_config = {}
+          @splitter_config = nil
+        end
+
+        class PatternIncompleteSplitterConfig < PatternParseFrontmatterPinlistVector
+          @platform = 'pattern_incomplete_splitter_config'
+          @parser_config = {}
+          @splitter_config = {
+            vectors_end: -1
+          }
+        end
+
+        class PatternNoVerify < PatternParseFrontmatterPinlistVector
+          @platform = 'pattern_no_verify'
+          @no_verify = true
+        end
+      end
+
+      module DummyWithDecompiler
+        def self.suitable_decompiler_for(pattern: nil, tester: nil, **options)
+          if pattern && (Pathname(pattern).extname == '.atp')
+            OrigenTesters::IGXLBasedTester
+          elsif tester && (tester == 'j750' || tester == 'uflex' || tester == 'ultraflex')
+            OrigenTesters::IGXLBasedTester
+          end
+        end
+      end
+
+      module DummyWithDecompilerMissingMethod
+      end
+    end
+  end
+end

data/lib/origen_testers/test/dut.rb

@@ -39,6 +39,18 @@ module OrigenTesters
           add_pin_group :pa, :pa2, :pa1, :pa0
           add_pin_alias :tdi_a, :tdi
         end
+
+        if options[:extra_pins]
+          options[:extra_pins].times do |i|
+            add_pin "PIN_#{i}".to_sym
+          end
+        end
+        # Add capitalized equivalent pins
+        add_pin_alias :TCLK, :tclk
+        add_pin_alias :TDI, :tdi
+        add_pin_alias :TDO, :tdo
+        add_pin_alias :TMS, :tms
+
         # add_pin_group :jtag, :tdi, :tdo, :tms
         add_power_pin_group :vdd1
         add_power_pin_group :vdd2

data/lib/origen_testers/test/dut2.rb

@@ -19,17 +19,30 @@ module OrigenTesters
         add_pin :tclk, reset: :drive_lo
         add_pin :trst, reset: :drive_hi
 
-        add_pin_alias :extal,     :clk
-        add_pin_alias :extal_mux, :clk_mux
-        add_pin_alias :tms,       :done
-        add_pin_alias :tdo,       :fail
-        add_pin_alias :tdi,       :invoke
-        add_pin_alias :resetb,    :ahvtst
+        add_pin_alias :extal,       :clk
+        add_pin_alias :extal_mux,   :clk_mux
+        add_pin_alias :tms,         :done
+        add_pin_alias :tdo,         :fail
+        add_pin_alias :tdi,         :invoke
+        add_pin_alias :resetb,      :ahvtst
+        add_pin_alias :nvm_reset,   :reset
+        add_pin_alias :nvm_clk,     :clk
+        add_pin_alias :nvm_clk_mux, :clk_mux
+        add_pin_alias :nvm_invoke,  :invoke
+        add_pin_alias :nvm_done,    :done
+        add_pin_alias :nvm_fail,    :fail
+        add_pin_alias :nvm_alvtst,  :alvtst
+        add_pin_alias :nvm_ahvtst,  :ahvtst
+        add_pin_alias :nvm_dtst,    :dtst
 
         add_pin_alias :pa5, :porta, pin: 5
         add_pin_alias :pa_lower, :porta, pins: [3..0]
         add_pin_alias :pa_upper, :porta, pins: [7, 6, 5, 4]
         add_pin_alias :porta_alias, :porta
+
+        pins.each do |name, pin|
+          add_pin_alias(name.upcase, name) unless has_pin?(name.upcase)
+        end
       end
 
       def startup(options)

data/lib/origen_testers/test/empty_dut.rb

@@ -0,0 +1,12 @@
+module OrigenTesters
+  module Test
+    class EmptyDUT
+      include OrigenARMDebug
+      include Origen::TopLevel
+      include OrigenJTAG
+
+      def initialize(options = {})
+      end
+    end
+  end
+end

data/lib/origen_testers/timing.rb

@@ -1,6 +1,21 @@
 module OrigenTesters
   module Timing
+    require 'origen_testers/timing/timeset'
+    require 'origen_testers/timing/timing_api'
+
     extend ActiveSupport::Concern
+    include TimingAPI
+
+    # Each time the toplevel is instantiated, we'll reset the timing, preserving
+    # the behavior when the timesets were stored on the tester object directly.
+    class TopLevelWatcher
+      include Origen::PersistentCallbacks
+
+      def before_load_target
+        OrigenTesters::Timing.reset!
+      end
+    end
+    @top_level_watcher = TopLevelWatcher.new
 
     included do
       # When set to true all pattern vectors will be converted to use the same period (the
@@ -29,359 +44,147 @@ module OrigenTesters
       attr_writer :timing_toggled_pins
     end
 
-    class Timeset
-      attr_accessor :name, :period_in_ns
+    def self.timesets!
+      @timesets = {}.with_indifferent_access
+    end
+
+    def self.reset!
+      timesets!
+      @timeset = nil
+      @_last_timeset_change = nil
+      @min_period_timeset = nil
+    end
 
-      def initialize(attrs = {})
-        attrs.each do |name, value|
-          send("#{name}=", value)
+    def self.set_timeset(timeset, period_in_ns = nil)
+      def self._set_timeset_(timeset, period_in_ns = nil)
+        # If the period_in_ns was given, use that.
+        # Alternatively, the period_in_ns may have been set on the Timeset object
+        # already.
+        # If not, then complain that we need a period_in_ns before proceeding.
+        if period_in_ns
+          timeset._period_in_ns_ = period_in_ns
+          # elsif !timeset.period_in_ns?
+          # fail 'You must supply a period_in_ns argument to set_timeset'
         end
-      end
 
-      # Returns true if the timeset has a shorter period than the supplied timeset
-      def shorter_period_than?(timeset)
-        period_in_ns < timeset.period_in_ns
+        if @timeset
+          timeset_changed(timeset)
+        else
+          @timeset = timeset
+        end
+        timeset.called = true
+        @timeset = timeset
+        timeset
       end
-    end
-
-    # @see Timing#level_period
-    #
-    # When period levelling is enabled, vectors will be expanded like this:
-    #   $tester.set_timeset("fast", 40)
-    #   2.cycles                        #    fast   1 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #   # Without levelling enabled
-    #   $tester.set_timeset("slow", 80)
-    #   2.cycles                        #    slow   1 0 0 1 0
-    #                                   #    slow   1 0 0 1 0
-    #   # With levelling enabled
-    #   $tester.set_timeset("slow", 80)
-    #   2.cycles                        #    fast   1 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #
-    # The overall time of the levelled/expanded vectors matches that of the unlevelled
-    # case. i.e. 4 cycles at fast speed (4 * 40ns = 160ns) is equivalent to 2 cycles
-    # at slow speed (2 * 80ns = 160ns).
-    #
-    # However, what if pin 1 in the example above was a clk pin where the 1 -> 0 transition
-    # was handled by the timing setup for that pin.
-    # In that case the levelled code is no longer functionally correct since it contains
-    # 4 clock pulses while the unlevelled code only has 2.
-    #
-    # Such pins can be specified via this attribute and the levelling logic will then
-    # automatically adjust the drive state to keep the number of pulses correct.
-    # It would automatically adjust to the alternative logic state where 0 means 'on'
-    # and 1 means 'off' if applicable.
-    #
-    #   $tester.timing_toggled_pins << $dut.pin(:tclk)  # This is pin 1
-    #
-    #   $tester.set_timeset("fast", 40)
-    #   2.cycles                        #    fast   1 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #   # Without levelling enabled
-    #   $tester.set_timeset("slow", 80)
-    #   2.cycles                        #    slow   1 0 0 1 0
-    #                                   #    slow   1 0 0 1 0
-    #   # With levelling enabled
-    #   $tester.set_timeset("slow", 80)
-    #   2.cycles                        #    fast   1 0 0 1 0
-    #                                   #    fast   0 0 0 1 0
-    #                                   #    fast   1 0 0 1 0
-    #                                   #    fast   0 0 0 1 0
-    #
-    # Multiple pins an be specified like this:
-    #   $tester.timing_toggled_pins = [$dut.pin(:tclk), $dut.pin(:clk)]   # Overrides any pins added elsewhere
-    #   $tester.timing_toggled_pins << [$dut.pin(:tclk), $dut.pin(:clk)]  # In addition to any pins added elsewhere
-    def timing_toggled_pins
-      @timing_toggled_pins ||= []
-      @timing_toggled_pins.flatten!
-      @timing_toggled_pins
-    end
 
-    # Set the timeset for the next vectors, this will remain in place until the next
-    # time this is called.
-    #
-    #   $tester.set_timeset("bist_25mhz", 40)
-    #
-    # This method also accepts a block in which case the contained vectors will generate
-    # with the supplied timeset and subsequent vectors will return to the previous timeset
-    # automatically.
-    #
-    #   $tester.set_timeset("bist_25mhz", 40) do
-    #     $tester.cycle
-    #   end
-    #
-    # The arguments can also be supplied as a single array, or not at all. In the latter case
-    # the existing timeset will simply be preserved. This is useful if you have timesets that
-    # can be conditionally set based on the target.
-    #
-    #   # Target 1
-    #   $soc.readout_timeset = ["readout", 120]
-    #   # Target 2
-    #   $soc.readout_timeset = false
-    #
-    #   # This code is compatible with both targets, in the first case the timeset will switch
-    #   # over, in the second case the existing timeset will be preserved.
-    #   $tester.set_timeset($soc.readout_timeset) do
-    #     $tester.cycle
-    #   end
-    def set_timeset(timeset, period_in_ns = nil)
       if timeset.is_a?(Array)
         timeset, period_in_ns = timeset[0], timeset[1]
       end
       timeset ||= @timeset
-      unless timeset.is_a?(Timeset)
-        fail 'You must supply a period_in_ns argument to set_timeset' unless period_in_ns
-        timeset = Timeset.new(name: timeset.to_s.chomp, period_in_ns: period_in_ns)
-      end
-      called_timesets << timeset unless called_timesets.map(&:name).include?(timeset.name)
-      if @min_period_timeset
-        @min_period_timeset = timeset if timeset.shorter_period_than?(@min_period_timeset)
-      else
-        @min_period_timeset = timeset
+      if timeset.is_a?(Origen::Pins::Timing::Timeset) || timeset.is_a?(OrigenTesters::Timing::Timeset)
+        timeset = timeset.id.to_sym
       end
+      timeset = (timesets[timeset] || lookup_or_register_timeset(timeset.to_s.chomp, period_in_ns: period_in_ns))
+
       if block_given?
         original = @timeset
-        timeset_changed(timeset)
-        @timeset = timeset
-        _if_dut do
-          dut.timeset = timeset.name if dut.timesets[timeset.name]
-          dut.current_timeset_period = timeset.period_in_ns
-        end
+        _set_timeset_(timeset, period_in_ns)
         yield
-        timeset_changed(original)
-        @timeset = original
-        _if_dut do
-          dut.timeset = original.name if dut.timesets[original.name]
-          dut.current_timeset_period = original.period_in_ns
-        end
-      else
-        timeset_changed(timeset)
-        @timeset = timeset
-        _if_dut do
-          dut.timeset = timeset.name if dut.timesets[timeset.name]
-          dut.current_timeset_period = timeset.period_in_ns
-        end
+        timeset = original
+        period_in_ns = timeset.period_in_ns
       end
-    end
+      _set_timeset_(timeset, period_in_ns)
 
-    # @api private
-    def _if_dut
-      if dut
-        yield
+      if @min_period_timeset && period_in_ns
+        @min_period_timeset = timeset if timeset.shorter_period_than?(@min_period_timeset)
       else
-        Origen.log.warning 'It looks like you are calling tester.set_timeset before the DUT is instantiated, you should avoid doing that until the dut object is available'
+        @min_period_timeset = timeset
       end
+      timeset
     end
+    singleton_class.send(:alias_method, :with_timeset, :set_timeset)
 
-    # Returns the timeset (a Timeset object) with the shortest period that has been
-    # encountered so far in the course of generating the current pattern.
-    #
-    # A tester object is re-instantiated at the start of every pattern which will reset
-    # this variable.
-    def min_period_timeset
+    def self.min_period_timeset
       @min_period_timeset
     end
 
-    def timeset_changed(timeset)
-      if last_vector && last_vector.timeset != timeset
-        change = { old: last_vector.timeset, new: timeset }
-        # Suppress any duplicate calls
-        if !@_last_timeset_change ||
-           (@_last_timeset_change[:new] != change[:new] &&
-             @_last_timeset_change[:old] != change[:old])
-          before_timeset_change(change)
-        end
-        @_last_timeset_change = change
-      end
-      if dut.timesets[timeset.name]
-        dut.timeset = timeset.name
-        dut.current_timeset_period = timeset.period_in_ns
-      end
-    end
-
-    def before_timeset_change(options = {})
-    end
-
-    # Cause the pattern to wait.
-    # The following options are available to help you specify the time to wait:
-    # * :cycles - delays specified in raw cycles, the test model is responsible for translating this into a sequence of valid repeat statements
-    # * :time_in_ns - time specified in nano-seconds
-    # * :time_in_us - time specified in micro-seconds
-    # * :time_in_ms - time specified in milli-seconds
-    # * :time_in_s - time specified in seconds
-    # If more than one option is supplied they will get added together to give a final
-    # delay time expressed in cycles.
-    # ==== Examples
-    #   $tester.wait(cycles: 100, time_in_ns: 200)   # Wait for 100 cycles + 200ns
-    # This method can also be used to trigger a match loop in which case the supplied time
-    # becomes the time out for the match. See the J750#match method for full details of the
-    # available options.
-    #   $tester.wait(match: true, state: :high, pin: $dut.pin(:done), time_in_ms: 500)
-    def wait(options = {})
-      options = {
-        cycles:         0,
-        time_in_cycles: 0,
-        time_in_us:     0,
-        time_in_ns:     0,
-        time_in_ms:     0,
-        time_in_s:      0,
-        match:          false,   # Set to true to invoke a match loop where the supplied delay
-        # will become the timeout duration
-      }.merge(options)
-
-      cycles = 0
-      cycles += options[:cycles] + options[:time_in_cycles]
-      cycles += s_to_cycles(options[:time_in_s])
-      cycles += ms_to_cycles(options[:time_in_ms])
-      cycles += us_to_cycles(options[:time_in_us])
-      cycles += ns_to_cycles(options[:time_in_ns])
-
-      time = cycles * current_period_in_ns   # Total delay in ns
-      case
-        when time < 1000                      # When less than 1us
-          cc "Wait for #{'a maximum of ' if options[:match]}#{time}ns"
-        when time < 1_000_000                   # When less than 1ms
-          cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1000).round(1)}us"        # Display delay in us
-        when time < 1_000_000_000                # When less than 1s
-          cc "Wait for #{'a maximum of ' if options[:match]}#{(time.to_f / 1_000_000).round(1)}ms"
-        else
-          cc "Wait for #{'a maximum of ' if options[:match]}%.2fs" % (time.to_f / 1_000_000_000)
-      end
-
-      if cycles > 0   # Allow this function to be called with 0 in which case it will just return
-        if options[:match]
-          if block_given?
-            match_block(cycles, options) { yield }
-          else
-            match(options[:pin], options[:state], cycles, options)
-          end
-        else
-          delay(cycles)
-        end
-      end
+    def self.timesets
+      @timesets || timesets!
     end
 
-    # @see Timing#wait
-    # @api private
-    # This should not be called directly, call via tester#wait
-    def delay(cycles, options = {})
-      (cycles / max_repeat_loop).times do
-        if block_given?
-          yield options.merge(repeat: max_repeat_loop)
-        else
-          cycle(options.merge(repeat: max_repeat_loop))
-        end
-      end
-      if block_given?
-        yield options.merge(repeat: (cycles % max_repeat_loop))
+    # Given a timeset name or object, either returns it, if it exists, or creates it, and returns
+    # the newly created timeset.
+    def self.lookup_or_register_timeset(t, period_in_ns: nil)
+      if t.is_a?(Origen::Pins::Timing::Timeset)
+        timesets[t.id] ||= Timeset.new(name: t.id, period_in_ns: period_in_ns)
       else
-        cycle(options.merge(repeat: (cycles % max_repeat_loop)))
+        timesets[t] ||= Timeset.new(name: t, period_in_ns: period_in_ns)
       end
     end
 
-    def max_repeat_loop
-      @max_repeat_loop || 65_535
-    end
-
-    def min_repeat_loop
-      @min_repeat_loop
-    end
-
-    def called_timesets
-      @called_timesets ||= []
-    end
-
-    def current_period_in_ns
-      if @timeset
-        @timeset.period_in_ns
+    # Returns true if the current timeset is defined. False otherwise.
+    def self.timeset?(t)
+      if t.respond_to?(:name)
+        timesets.key?(t.name)
       else
-        fail 'No timeset has been specified yet!'
+        timesets.key?(t)
       end
     end
-    alias_method :current_period, :current_period_in_ns
-    alias_method :period, :current_period_in_ns
 
-    def current_timeset
+    def self.timeset
       @timeset
     end
-    alias_method :timeset, :current_timeset
 
-    # Convert the supplied number of cycles to a time, based on the SoC defined cycle period
-    def cycles_to_time(cycles) # :nodoc:
-      (cycles * current_period_in_ns).to_f / 1_000_000_000
+    def self.current_timeset
+      @timeset
     end
 
-    # This function can be used to generate a clock or some other repeating function
-    # that spans accross a range of vectors.
-    # The period of each cycle and the duration of the sequence are supplied via the following
-    # options:
-    # * :period_in_cycles
-    # * :period_in_ns
-    # * :period_in_us
-    # * :period_in_ms
-    # * :duration_in_cycles
-    # * :duration_in_ns
-    # * :duration_in_us
-    # * :duration_in_ms
-    # If multiple definitions for either option are supplied then they will be added
-    # together.
-    # ==== Example
-    #   # Supply a clock pulse on :pinA for 100ms
-    #   $tester.count(:period_in_cycles => 10, :duration_in_ms => 100) do
-    #       $top.pin(:pinA).drive!(1)
-    #       $top.pin(:pinA).drive!(0)
-    #   end
-    def count(options = {})
-      options = { period_in_cycles: 0, period_in_ms: 0, period_in_us: 0, period_in_ns: 0,
-                  duration_in_cycles: 0, duration_in_ms: 0, duration_in_us: 0, duration_in_ns: 0
-                }.merge(options)
-
-      period_cycles = options[:period_in_cycles] + ms_to_cycles(options[:period_in_ms]) +
-                      us_to_cycles(options[:period_in_us]) + ns_to_cycles(options[:period_in_ns])
-
-      duration_cycles = options[:duration_in_cycles] + ms_to_cycles(options[:duration_in_ms]) +
-                        us_to_cycles(options[:duration_in_us]) + ns_to_cycles(options[:duration_in_ns])
-
-      total = 0
-      while total < duration_cycles
-        wait(time_in_cycles: period_cycles)
-        yield								# Return control back to caller
-        total += period_cycles
+    def self.period_in_ns
+      if timeset
+        timeset.period_in_ns
       end
     end
 
-    private
-
-    def s_to_cycles(time) # :nodoc:
-      ((time.to_f) * 1000 * 1000 * 1000 / current_period_in_ns).to_int
-    end
-
-    def ms_to_cycles(time) # :nodoc:
-      ((time.to_f) * 1000 * 1000 / current_period_in_ns).to_int
-    end
-
-    def us_to_cycles(time) # :nodoc:
-      ((time.to_f * 1000) / current_period_in_ns).to_int
+    def self.timeset_changed(timeset)
+      if tester && tester.last_vector && tester.last_vector.timeset != timeset
+        change = { old: tester.last_vector.timeset, new: timeset }
+        # Suppress any duplicate calls
+        if !@_last_timeset_change ||
+           (@_last_timeset_change[:new] != change[:new] &&
+             @_last_timeset_change[:old] != change[:old])
+          tester.before_timeset_change(change)
+        end
+        @_last_timeset_change = change
+      end
     end
 
-    def ns_to_cycles(time) # :nodoc:
-      (time.to_f / current_period_in_ns).to_int
+    def self.current_period_in_ns
+      if timeset
+        timeset.period_in_ns
+      end
     end
+    singleton_class.send(:alias_method, :period, :current_period_in_ns)
+    singleton_class.send(:alias_method, :current_period, :current_period_in_ns)
+    singleton_class.send(:alias_method, :period_in_ns, :current_period_in_ns)
 
-    def cycles_to_us(cycles) # :nodoc:
-      ((cycles.to_f * current_period_in_ns) / (1000)).ceil
+    def self.period_in_secs
+      if timeset
+        timeset.period_in_secs
+      end
     end
+    singleton_class.send(:alias_method, :period_in_seconds, :period_in_secs)
 
-    def cycles_to_ms(cycles) # :nodoc:
-      ((cycles.to_f * current_period_in_ns) / (1000 * 1000)).ceil
+    # Returns any timesets that have been called during this execution.
+    # @return [Array] Array of OrigenTesters::Timing::Timeset objects that have been used so far.
+    def self.called_timesets
+      timesets.select { |n, t| t.called? }.values
     end
+    # alias_method :called_timesets_by_instance, :called_timesets
 
-    # Cycles to tenths of a second
-    def cycles_to_ts(cycles) # :nodoc:
-      ((cycles.to_f * current_period_in_ns) / (1000 * 1000 * 100)).ceil
+    # Similar to {#called_timesets}, but returns the name of the timesets instead.
+    # @return [Array] Array of names corresponding to the timesets that have been used so far.
+    def self.called_timesets_by_name
+      timesets.select { |n, t| t.called? }.keys
     end
   end
 end