origen_testers 0.4.0

data/lib/origen_testers/smartest_based_tester/v93k/templates/template.pmfl.erb

@@ -0,0 +1,13 @@
+hp93000,pattern_master_file,0.1
+
+% p = options[:program] ? options[:program].paths : paths
+% p.each do |path, patterns|
+path:
+<%= path %>
+
+files:
+%   patterns.uniq.sort.each do |pattern|
+<%= pattern %>
+%   end
+
+% end

data/lib/origen_testers/smartest_based_tester/v93k/test_method.rb

@@ -0,0 +1,9 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K
+      require 'origen_testers/smartest_based_tester/base/test_method'
+      class TestMethod < Base::TestMethod
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k/test_methods.rb

@@ -0,0 +1,9 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K
+      require 'origen_testers/smartest_based_tester/base/test_methods'
+      class TestMethods < Base::TestMethods
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k/test_suite.rb

@@ -0,0 +1,9 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K
+      require 'origen_testers/smartest_based_tester/base/test_suite'
+      class TestSuite < Base::TestSuite
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k/test_suites.rb

@@ -0,0 +1,9 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K
+      require 'origen_testers/smartest_based_tester/base/test_suites'
+      class TestSuites < Base::TestSuites
+      end
+    end
+  end
+end

data/lib/origen_testers/test/basic_interface.rb

@@ -0,0 +1,17 @@
+module OrigenTesters
+  module Test
+    # A simple interface designed to test the Testers::BasicTestSetups module
+    class BasicInterface
+      include OrigenTesters::BasicTestSetups
+
+      def functional(name, options = {})
+        # Apply custom defaults before calling
+        options = {
+          bin: 3
+        }.merge(options)
+        # Now call the generator
+        super
+      end
+    end
+  end
+end

data/lib/origen_testers/test/block.rb

@@ -0,0 +1,21 @@
+module OrigenTesters
+  module Test
+    class Block
+      attr_accessor :id, :selected
+
+      def initialize(id, owner)
+        @id = id
+        @selected = false
+        @owner = owner
+      end
+
+      def select
+        @selected = true
+      end
+
+      def owner
+        @owner
+      end
+    end
+  end
+end

data/lib/origen_testers/test/dut.rb

@@ -0,0 +1,184 @@
+module OrigenTesters
+  module Test
+    class DUT
+      # Simple DUT using Nexus interface
+
+      attr_accessor :blocks
+      attr_accessor :hv_supply_pin
+      attr_accessor :lv_supply_pin
+
+      include OrigenARMDebug
+      include Origen::TopLevel
+      include OrigenJTAG
+
+      def initialize(options = {})
+        add_pin :tclk
+        add_pin :tdi
+        add_pin :tdo
+        add_pin :tms
+
+        add_reg32 :testme32, 0x007a do
+          bits 31..16, :portB
+          bits 15..8,  :portA
+          bits 1,      :done
+          bits 0,      :enable
+        end
+        @hv_supply_pin = 'VDDHV'
+        @lv_supply_pin = 'VDDLV'
+        @blocks = [Block.new(0, self), Block.new(1, self), Block.new(2, self)]
+      end
+
+      def startup(options)
+        $tester.set_timeset('tp0', 60)
+      end
+
+      def write_register(reg, options = {})
+        arm_debug.write_register(reg, options)
+      end
+
+      def read_register(reg, options = {})
+        arm_debug.write_register(reg, options)
+      end
+
+      def execute(options = {})
+        options = { define: false,          # whether to define subr or call it
+                    name:   'executefunc1'
+                }.merge(options)
+
+        if options[:define]
+          # define subroutine
+          $tester.start_subroutine(options[:name])
+          $tester.cycle
+          $tester.end_subroutine
+          $tester.cycle
+        else
+          # call subroutine
+          $tester.cycle
+          $tester.call_subroutine(options[:name])
+          $tester.cycle
+        end
+      end
+
+      # Match loop functionality
+      def match(options = {})
+        options = { type:        :match_pin,    # whether to match DONE bit in register or match pin
+                    # :match_done
+                    # :match_2pins
+                    delay_in_us: 5,           # match loop delay
+                    define:      false,       # whether to define subr or call it
+                    subr_name:   false,       # default use match type as subr name
+                }.merge(options)
+
+        subr_name = options[:subr_name] ? options[:subr_name] : options[:type].to_s
+
+        if options[:define]
+          $tester.start_subroutine(subr_name)
+          $tester.cycle
+          if options[:type] == :match_done
+
+            # Match DONE bit in register
+            $tester.wait(match:                 true,
+                         time_in_us:            options[:delay_in_us],
+                         global_loops:          true,
+                         check_for_fails:       true,
+                         force_fail_on_timeout: true,
+                         clr_fail_post_match:   true,
+                         manual_stop:           true) do
+              # Match on reading done bit
+              reg(:testme32).bits(:done).write(1)
+              reg(:testme32).bits(:done).read!
+            end
+          elsif options[:type] == :match_pin
+            # Match on TDO pin state
+            $tester.wait(match:                 true,
+                         pin:                   pin(:tdo),
+                         state:                 :high,
+                         time_in_us:            options[:delay_in_us],
+                         global_loops:          true,
+                         check_for_fails:       true,
+                         force_fail_on_timeout: true,
+                         clr_fail_post_match:   true,
+                         manual_stop:           true)
+          elsif options[:type] == :match_2pins
+            # Match on TDO pin state
+            $tester.wait(match:                 true,
+                         pin:                   pin(:tdo),
+                         state:                 :high,
+                         pin2:                  pin(:tms),
+                         state2:                :high,
+                         time_in_us:            options[:delay_in_us],
+                         global_loops:          true,
+                         check_for_fails:       true,
+                         force_fail_on_timeout: true,
+                         clr_fail_post_match:   true,
+                         manual_stop:           true)
+          elsif options[:type] == :multiple_entries
+            # Match on TDO pin state, with multiple subr entry points
+            $tester.wait(match:                 true,
+                         pin:                   pin(:tdo),
+                         state:                 :high,
+                         time_in_us:            options[:delay_in_us],
+                         global_loops:          true,
+                         multiple_entries:      true,
+                         check_for_fails:       true,
+                         force_fail_on_timeout: true,
+                         clr_fail_post_match:   true,
+                         manual_stop:           true)
+          end
+          $tester.cycle
+          $tester.end_subroutine
+          $tester.cycle
+        else
+          # call subroutine
+          $tester.cycle
+          $tester.call_subroutine(subr_name)
+          $tester.cycle
+        end
+      end
+
+      def handshake(options = {})
+        options = {
+          define: false,          # whether to define subr or call it
+        }.merge(options)
+
+        if options[:define]
+          $tester.start_subroutine('handshake')
+          $tester.handshake(readcode: 100)
+          $tester.cycle
+          $tester.cycle
+          $tester.cycle
+          $tester.end_subroutine
+        else
+          $tester.cycle
+          $tester.call_subroutine('handshake')
+        end
+      end
+
+      def memory_test(options = {})
+        options = {
+        }.merge(options)
+
+        $tester.memory_test(inc_counter_x: true, gen_vector: true)
+
+        $tester.memory_test(inc_counter_y: true, gen_vector: true)
+
+        $tester.memory_test(init_counter_x: true)
+
+        $tester.memory_test(inc_counter_x: true, init_counter_y: true)
+
+        $tester.memory_test(inc_counter_y: true, capture_vector: true)
+
+        $tester.memory_test(pin: pin(:tdo), pin_data: :expect)
+      end
+
+      # dummy flag to check for a particular design bug for this DUT
+      def has_margin0_bug?
+        false
+      end
+
+      def find_block_by_id(id)
+        @blocks.find { |block| block.id == id }
+      end
+    end
+  end
+end

data/lib/origen_testers/test/dut2.rb

@@ -0,0 +1,76 @@
+module OrigenTesters
+  module Test
+    class DUT2
+      include Origen::TopLevel
+
+      def initialize
+        add_pin :reset,   reset: :drive_hi,  name: 'nvm_reset'
+        add_pin :clk,     reset: :drive_hi,  name: 'nvm_clk'
+        add_pin :clk_mux, reset: :drive_hi,  name: 'nvm_clk_mux'
+        add_port :porta,   reset: :drive_lo,  size: 8
+        add_port :portb,   reset: :drive_lo,  size: 8, endian: :little
+        add_pin :invoke,  reset: :drive_lo,  name: 'nvm_invoke'
+        add_pin :done,    reset: :expect_hi, name: 'nvm_done'
+        add_pin :fail,    reset: :expect_lo, name: 'nvm_fail'
+        add_pin :alvtst,  reset: :dont_care, name: 'nvm_alvtst'
+        add_pin :ahvtst,  reset: :dont_care, name: 'nvm_ahvtst'
+        add_pin :dtst,    reset: :dont_care, name: 'nvm_dtst'
+
+        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 :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_port_alias :porta_alias, :porta
+      end
+
+      def startup(options)
+        if options[:add_additional_pins]
+          add_pin :late_added_pin, reset: :drive_hi
+        else
+          # Test that rendering some vectors from a template works...
+          if $tester.is_a?(J750)
+            $tester.render("#{Origen.root}/pattern/nvm/j750/_mode_entry.atp.erb", hold_cycles: 5)
+          end
+        end
+        $tester.set_timeset('nvmbist', 40) if $tester.is_vector_based?
+      end
+
+      def has_margin0_bug?
+        false
+      end
+
+      def write_register(reg, options = {})
+        reg
+      end
+
+      def read_register(reg, options = {})
+        reg
+      end
+
+      def base_address(reg, options = {})
+        if reg.owned_by?(:nvm)
+          0x4000_0000
+        else
+          0
+        end
+      end
+
+      def origen_dot_root
+        Origen.root
+      end
+
+      def origen_dot_root!
+        Origen.root!
+      end
+    end
+  end
+end

data/lib/origen_testers/test/j750_base_interface.rb

@@ -0,0 +1,119 @@
+module OrigenTesters
+  module Test
+    class J750BaseInterface
+      # Options passed to Flow.create and Library.create will be passed in here, use as
+      # desired to configure your interface
+      def initialize(options = {})
+      end
+
+      def log(msg)
+        flow.logprint(msg)
+      end
+
+      def func(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        block_loop(name, options) do |block, i, group|
+          ins = test_instances.functional(name)
+          ins.set_wait_flags(:a) if options[:duration] == :dynamic
+          ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
+          if group
+            pname = "#{name}_b#{i}_pset"
+            patsets.add(pname, [{ pattern: "#{name}_b#{i}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            flow.test(group, options) if i == 0
+          else
+            pname = "#{name}_pset"
+            patsets.add(pname, [{ pattern: "#{name}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            if options[:cz_setup]
+              flow.cz(ins, options[:cz_setup], options)
+            else
+              flow.test(ins, options)
+            end
+          end
+        end
+      end
+
+      def block_loop(name, options)
+        if options[:by_block]
+          test_instances.group do |group|
+            group.name = name
+            $dut.blocks.each_with_index do |block, i|
+              yield block, i, group
+            end
+          end
+        else
+          yield
+        end
+      end
+
+      def por(options = {})
+        options = {
+          instance_not_available: true
+        }.merge(options)
+        flow.test('por_ins', options)
+      end
+
+      def para(name, options = {})
+        options = {
+          high_voltage: false
+        }.merge(options)
+        if options.delete(:high_voltage)
+          ins = test_instances.bpmu(name)
+        else
+          ins = test_instances.ppmu(name)
+        end
+        ins.dc_category = 'NVM_PARA'
+        flow.test(ins, options)
+        patsets.add("#{name}_pset", pattern: "#{name}.PAT")
+      end
+      alias_method :meas, :para
+
+      # OR 2 IDS together into 1 flag
+      def or_ids(options = {})
+        flow.or_flags(options[:id1], options[:id2], options)
+      end
+
+      def nop(options = {})
+        flow.nop options
+      end
+
+      def mto_memory(name, options = {})
+        options = {
+          duration: :static
+        }.merge(options)
+
+        block_loop(name, options) do |block, i, group|
+          ins = test_instances.mto_memory(name)
+          ins.set_wait_flags(:a) if options[:duration] == :dynamic
+          ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
+          if group
+            pname = "#{name}_b#{i}_pset"
+            patsets.add(pname, [{ pattern: "#{name}_b#{i}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            flow.test(group, options) if i == 0
+          else
+            pname = "#{name}_pset"
+            patsets.add(pname, [{ pattern: "#{name}.PAT" },
+                                { pattern: 'nvm_global_subs.PAT', start_label: 'subr' }])
+            ins.pattern = pname
+            if options[:cz_setup]
+              flow.cz(ins, options[:cz_setup], options)
+            else
+              flow.test(ins, options)
+            end
+          end
+        end
+      end
+
+      def bin(number, options = {})
+      end
+    end
+  end
+end