origen_testers 0.4.0

data/lib/origen_testers/igxl_based_tester/base/test_instance_group.rb

@@ -0,0 +1,58 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TestInstanceGroup
+        attr_accessor :name, :version, :append_version
+
+        include Enumerable
+
+        def initialize(name, options = {})
+          @name = name
+          @store = []
+          @append_version = true
+        end
+
+        def name
+          if unversioned_name
+            if version && @append_version
+              "#{unversioned_name}_v#{version}"
+            else
+              unversioned_name.to_s
+            end
+          end
+        end
+
+        def unversioned_name
+          if @name
+            if @name =~ /grp$/
+              @name
+            else
+              "#{@name}_grp"
+            end
+          end
+        end
+
+        def <<(instance)
+          @store << instance
+        end
+
+        def size
+          @store.size
+        end
+
+        def each
+          @store.each { |ins| yield ins }
+        end
+
+        def ==(other_instance_group)
+          self.class == other_instance_group.class &&
+            unversioned_name.to_s == other_instance_group.unversioned_name.to_s &&
+            size == other_instance_group.size &&
+            self.all? do |ins|
+              other_instance_group.any? { |other_ins| ins == other_ins }
+            end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/test_instances.rb

@@ -0,0 +1,179 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TestInstances
+        include OrigenTesters::Generator
+
+        OUTPUT_POSTFIX = 'instances'
+
+        class IndexedString < ::String
+          attr_accessor :index
+
+          def name
+            self
+          end
+        end
+
+        def add(name, type, options = {})
+          options = {
+            test_instance_class: platform::TestInstance
+          }.merge(options)
+          ins = options.delete(:test_instance_class).new(name, type, options)
+          if @current_group
+            @current_group << ins
+          else
+            collection << ins
+          end
+          c = Origen.interface.consume_comments
+          Origen.interface.descriptions.add_for_test_definition(name, c)
+          ins
+        end
+
+        # IG-XL doesn't have a formal instance group type and instead declares them anonymously
+        # whenever test instances of the same name appear consecutively in the test instance sheet.
+        # However when it comes to generating a test program life becomes much easier if we have
+        # a way to explicitly declare instances as part of a group - this makes duplicate tracking
+        # and sorting of the test instance sheet much easier.
+        #
+        # Use this method to generate instance groups via a block. Within the block you should
+        # generate instances as normal and they will automatically be assigned to the current group.
+        # Note that the name of the instances generated within the group is discarded and replaced
+        # with the name of the group. Origen automatically appends "grp" to this name to highlight
+        # instances that were generated as part of the group.
+        #
+        #   test_instances.group("erase_all_blocks") do |group|
+        #     # Generate instances here as normal
+        #     test_instances.functional("erase_blk0")
+        #     test_instances.functional("erase_blk1")
+        #   end
+        #
+        # The group object is passed into the block but usually you should not need to interact
+        # with this directly except maybe to set the name if it is not yet established at the point
+        # where the group is initiated:
+        #
+        #   test_instances.group do |group|
+        #     # Generate instances here as normal
+        #     group.name = "group_blah"
+        #   end
+        #
+        # A common way to generate groups is to create a helper method in your application which
+        # is responsible for creating groups as required:
+        #
+        #   def group_wrapper(name, options)
+        #     if options[:by_block]
+        #       test_instances.group(name) do |group|
+        #         yield group
+        #       end
+        #     else
+        #       yield
+        #     end
+        #   end
+        #
+        # In that case the group argument becomes quite useful for branching based on whether you
+        # are generating a group or standalone instances:
+        #
+        #  group_wrapper(name, options) do |group|
+        #    if group
+        #      # Generate group instances
+        #    else
+        #      # Generate standalone instances
+        #    end
+        #  end
+        def group(name = nil, options = {})
+          name, options = nil, name if name.is_a?(Hash)
+          @current_group = platform::TestInstanceGroup.new(name, options)
+          collection << @current_group
+          yield @current_group
+          @current_group = nil
+        end
+        alias_method :add_group, :group
+
+        def finalize(options = {}) # :nodoc:
+          uniq!
+          sort!
+        end
+
+        def uniq! # :nodoc:
+          uniques = []
+          versions = {}
+          multi_version_tests = {}
+          collection.each do |instance|
+            # If a uniquely named instance is found add it, otherwise update the version
+            # of the current instance to match that of the existing instance that it duplicates
+            unless uniques.any? do |i|
+              if i == instance
+                instance.version = i.version
+                true
+              else
+                false
+              end
+            end
+              if instance.respond_to?(:version=)
+                versions[instance.unversioned_name] ||= 0
+                versions[instance.unversioned_name] += 1
+                if versions[instance.unversioned_name] > 1
+                  multi_version_tests[instance.unversioned_name] = true
+                end
+                instance.version = versions[instance.unversioned_name]
+              end
+              uniques << instance
+            end
+          end
+          # This final loop disables the version identifier for tests that have only a single version,
+          # this makes it clearer when multiple versions exist - whenever you see a v1 you know there
+          # is at least a v2 also.
+          collection.map! do |instance|
+            if instance.respond_to?(:version=)
+              unless multi_version_tests[instance.unversioned_name]
+                instance.append_version = false
+              end
+            end
+            instance
+          end
+          self.collection = uniques
+        end
+
+        def sort! # :nodoc:
+          # Present the instances in the final sheet in alphabetical order
+          collection.map!.with_index do |ins, i|
+            if ins.is_a?(String)   # Can happen if content has been rendered in from a template
+              ins = IndexedString.new(ins)
+            end
+            ins
+          end
+          collection.sort! { |a, b| [a.name.to_s] <=> [b.name.to_s] }
+        end
+
+        def bpmu(name, options = {})
+          add(name, :board_pmu, options)
+        end
+        alias_method :board_pmu, :bpmu
+
+        def ppmu(name, options = {})
+          add(name, :pin_pmu, options)
+        end
+        alias_method :pin_pmu, :ppmu
+
+        def functional(name, options = {})
+          add(name, :functional, options)
+        end
+
+        def empty(name, options = {})
+          add(name, :empty, options)
+        end
+
+        def other(name, options = {})
+          add(name, :other, options)
+        end
+
+        def apmu_powersupply(name, options = {})
+          add(name, :apmu_powersupply, options)
+        end
+
+        def mto_memory(name, options = {})
+          add(name, :mto_memory, options)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/files.rb

@@ -0,0 +1,43 @@
+module OrigenTesters
+  module IGXLBasedTester
+    # Methods for handling all J750 file parsing, e.g. datalogs,
+    # test time profiles, etc.
+    module Files
+      # Reads all lines from a J750 detailed execution time file, returning the lines
+      # as an array like this:
+      #
+      #   [
+      #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
+      #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
+      #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
+      #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
+      #   ]
+      def read_test_times(file, options = {})
+        tests = []
+        File.readlines(file).each do |line|
+          unless line.strip.empty? || line =~ /Entire Job/
+            # http://rubular.com/r/vZOcqovTsf
+            if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
+              t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
+              # If an indexed test
+              if Regexp.last_match[2]
+                str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
+                fields = str.split('/')
+                i = fields[0].to_i
+                g = fields[1].to_i
+                t[:index] = i
+                t[:group] = g
+
+              else
+                t[:index] = nil
+                t[:group] = nil
+              end
+              tests << t
+            end
+          end
+        end
+        tests
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/j750.rb

@@ -0,0 +1,248 @@
+module OrigenTesters
+  module IGXLBasedTester
+    # Tester model to generate .atp patterns for the Teradyne J750
+    #
+    # == Basic Usage
+    #   $tester = Testers::J750.new
+    #   $tester.cycle       # Generate a vector
+    #
+    # Many more methods exist to generate J750 specific micro-code, see below for
+    # details.
+    #
+    # Also note that this class inherits from the base Tester class and so all methods
+    # described there are also available.
+    class J750 < Base
+      require 'origen_testers/igxl_based_tester/j750/generator.rb'
+
+      attr_accessor :use_hv_pin
+      attr_accessor :software_version
+
+      def self.hpt_mode
+        @@hpt_mode
+      end
+      def self.hpt_mode?
+        @@hpt_mode
+      end
+
+      # Returns a new J750 instance, normally there would only ever be one of these
+      # assigned to the global variable such as $tester by your target.
+      def initialize
+        super
+        @pipeline_depth = 34  # for extended mode is vectors, for normal mode is vector pairs (54 for J750Ex)
+        @use_hv_pin = false   # allows to use high voltage for a pin for all patterns
+        @software_version = '3.50.40'
+        @name = 'j750'
+        @@hpt_mode = false
+        @opcode_mode = :extended
+        @loop_bits_max = 16             # maximum loop bit length
+
+        @flags = %w(cpuA cpuB cpuC cpuD)
+        @microcode[:enable] = 'enable'
+        @microcode[:set_flag] = 'set_cpu'
+        @microcode[:mask_vector] = 'ign ifc icc'
+      end
+
+      def pattern_header(options = {})
+        super(options) do |pin_list|
+          microcode "vector ($tset, #{pin_list})"
+          microcode '{'
+          unless options[:subroutine_pat]
+            microcode 'start_label pattern_st:'
+          end
+        end
+      end
+
+      def pattern_footer(options = {})
+        super(options)
+      end
+
+      # Generates a match loop based on vector condition passed in via block
+      #
+      # This method is not really intended to be called directly, rather you should call
+      # via Tester#wait:
+      #      e.g. $tester.wait(:match => true) do
+      #             reg(:status_reg).bit(:done).read(1)!  # vector condition that you want to match
+      #           end
+      #
+      # The timeout should be provided in cycles, however when called via the wait method the
+      # time-based helpers (time_in_us, etc) will be converted to cycles for you.
+      #
+      # The following options are available to tailor the match loop behavior, defaults in
+      # parenthesis:
+      # * :check_for_fails (false) - Flushes the pipeline and handshakes with the tester (passing readcode 100) prior to the match (to allow binout of fails encountered before the match)
+      # * :force_fail_on_timeout (true) - Force a vector mis-compare if the match loop times out
+      # * :on_timeout_goto ("") - Optionally supply a label to branch to on timeout, by default will continue from the end of the match loop
+      # * :on_block_match_goto ("") - Optionally supply a label to branch to when block condition is met, by default will continue from the end of the match loop
+      # * :multiple_entries (false) - Supply an integer to generate multiple entries into the match (each with a unique readcode), this can be useful when debugging patterns with multiple matches
+      # * :force_fail_on_timeout (true) - force pattern to fail if timeout occurs
+      # * :global_loops (false) - whether match loop loops should use global labels
+      # * :manual_stop (false) - whether to use extra cpuB flag to resolve IG-XL v.3.50.xx bug where VBT clears cpuA immediately
+      #                          at start of PatFlagFunc instead of at end.  Use will have to manually clear cpuB to resume this pattern.
+      # ==== Examples
+      #   $tester.wait(:match => true, :time_in_us => 5000, :pin => $top.pin(:done), :state => :high) do
+      #     <vectors>
+      #   end
+      def match_block(timeout, options = {}, &block)
+        options = {
+          check_for_fails:       false,
+          on_timeout_goto:       false,
+          on_block_match_goto:   false,
+          multiple_entries:      false,
+          force_fail_on_timeout: true,
+          global_loops:          false,
+          manual_stop:           false,
+          clr_fail_post_match:   false
+        }.merge(options)
+
+        unless block_given?
+          fail 'ERROR: block not passed to match_block!'
+        end
+
+        # Create BlockArgs objects in order to receive multiple blocks
+        match_conditions = Origen::Utility::BlockArgs.new
+        fail_conditions = Origen::Utility::BlockArgs.new
+
+        # yield object to calling routine to get populated with blocks
+        if block.arity > 0
+          yield match_conditions, fail_conditions
+        else
+          # for backwards compatibility with Origen core call to match_block
+          match_conditions.add(&block)
+          fail_conditions.add(&block)
+        end
+
+        # Flush the pipeline first and then pass control to the program to bin out any failures
+        # prior to entering the match loop
+        if options[:check_for_fails]
+          if options[:multiple_entries]
+            @match_entries.times do |i|
+              microcode "global subr match_done_#{i}:"
+              set_code(i + 100)
+              cycle(microcode: 'jump call_tester') unless i == @match_entries - 1
+            end
+            microcode 'call_tester:'
+          else
+            set_code(100)
+          end
+          cc 'Wait for any prior failures to propagate through the pipeline'
+          cycle(microcode: 'pipe_minus 1')
+          cc 'Now handshake with the tester to bin out and parts that have failed before they got here'
+          handshake(manual_stop: options[:manual_stop])
+        end
+
+        # Now do the main match loop
+        cc 'Start the match loop'
+
+        global_opt = (options[:global_loops]) ? 'global ' : ''
+        microcode "#{global_opt}match_outer_loop_#{@unique_counter}:"
+        cycle # (:microcode => "loopB #{outer_loop_count} ign ifc icc")
+        set_loopb_vector = last_vector
+
+        microcode "#{global_opt}match_inner_loop_#{@unique_counter}:"
+        cycle # (:microcode => "loopA #{inner_loop_count} ign ifc icc")
+        set_loopa_vector = last_vector
+
+        # count cycles in match loop block passed to help with meeting
+        # desired timeout value (have to back assign microcodes above)
+        prematch_cycle_count = cycle_count
+        match_conditions.each_with_index do |condition, i|
+          mask_fails(true)
+          condition.call  # match condition
+          mask_fails(false)
+          cc ' Wait for the result to propagate through the pipeline'
+          cycle(microcode: 'pipe_minus 1 ign ifc icc')
+          inc_cycle_count(@pipeline_depth - 1)                   # Account for pipeline depth
+          cc "Branch if block condition #{i} met"
+          cycle(microcode: "if (pass) jump block_#{i}_matched_#{@unique_counter} icc ifc")
+          cycle(microcode: 'clr_flag (fail) icc')
+        end
+        match_conditions_cycle_count = cycle_count - prematch_cycle_count
+        cc "Match loop cycle count = #{match_conditions_cycle_count}"
+
+        # reduce timeout requested by match loop cycle count
+        timeout = (timeout.to_f / match_conditions_cycle_count).ceil
+
+        # Calculate the loop counts for the 2 loops to appropriately hit the timeout requested
+        loop_value = timeout.to_f.floor
+
+        if loop_value < (2**@loop_bits_max)
+          # small value, only need to use one loop
+          outer_loop_count = 1
+          inner_loop_count = loop_value
+        elsif loop_value < (2**(2 * @loop_bits_max))
+          # 2 nested loops required
+          inner_loop_count = 2**@loop_bits_max - 1
+          outer_loop_count = (loop_value.to_f / inner_loop_count).ceil
+        else
+          abort 'ERROR: timeout value too large in tester match method!'
+        end
+
+        # retroactively set loop counter values for timeout based on cycles in match loop condition
+        set_loopb_vector.microcode = "loopB #{outer_loop_count} ign ifc icc"
+        set_loopa_vector.microcode = "loopA #{inner_loop_count} ign ifc icc"
+
+        cc 'Loop back around if time remaining'
+        cycle(microcode: "end_loopA match_inner_loop_#{@unique_counter} icc")
+        cycle(microcode: "end_loopB match_outer_loop_#{@unique_counter} icc")
+
+        if options[:force_fail_on_timeout]
+          cc 'To get here something has gone wrong, check block again to force a pattern failure'
+          fail_conditions.each(&:call)
+        end
+
+        if options[:on_timeout_goto]
+          cycle(microcode: "jump #{options[:on_timeout_goto]} icc")
+        else
+          cycle(microcode: "jump match_loop_end_#{@unique_counter} icc")
+          # cycle(:microcode => 'halt')
+        end
+        match_conditions.each_with_index do |condition, i|
+          microcode "block_#{i}_matched_#{@unique_counter}:"
+          cycle(microcode: 'pop_loop icc')
+        end
+        if options[:clr_fail_post_match]
+          cycle(microcode: 'clr_fail')
+        end
+        if options[:on_block_match_goto]
+          cycle(microcode: "jump #{options[:on_block_match_goto]}")
+        end
+        microcode "match_loop_end_#{@unique_counter}:"
+        if options[:clr_fail_post_match]
+          cycle(microcode: 'clr_fail')
+        end
+
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+
+      # Handshake with the tester.
+      #
+      # Will set a cpu flag (A) and wait for it to be cleared by the tester, optionally
+      # pass in a read code to pass information to the tester.
+      #
+      # ==== Examples
+      #   $tester.handshake                   # Pass control to the tester for a measurement
+      #   $tester.handshake(:readcode => 10)  # Trigger a specific action by the tester
+      def handshake(options = {})
+        options = {
+          readcode:    false,
+          manual_stop: false,    # set a 2nd CPU flag in case 1st flag is automatically cleared
+        }.merge(options)
+        if options[:readcode]
+          set_code(options[:readcode])
+        end
+        if options[:manual_stop]
+          cycle(microcode: "#{@microcode[:enable]} (#{@flags[1]})")
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]} #{@flags[1]})")
+          cycle(microcode: "loop_here_#{@unique_counter}: if (flag) jump loop_here_#{@unique_counter}")
+        else
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]})")
+          cycle(microcode: "loop_here_#{@unique_counter}: if (#{@flags[0]}) jump loop_here_#{@unique_counter}")
+        end
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+    end
+  end
+  J750 = IGXLBasedTester::J750
+end