origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/test/dut2.rb

@@ -1,76 +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_pin :porta,   reset: :drive_lo,  size: 8
-        add_pin :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_pin_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
+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_pin :porta,   reset: :drive_lo,  size: 8
+        add_pin :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_pin_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/dut3.rb

@@ -1,244 +1,244 @@
-module OrigenTesters
-  module Test
-    class DUT3
-      # Simple DUT using Nexus interface
-
-      attr_accessor :blocks
-      attr_accessor :hv_supply_pin
-      attr_accessor :lv_supply_pin
-      attr_accessor :digsrc_pins
-      attr_accessor :digcap_pins
-      attr_accessor :digsrc_settings
-      attr_accessor :digcap_settings
-
-      include OrigenARMDebug
-      include Origen::TopLevel
-      include OrigenJTAG
-
-      def initialize(options = {})
-        add_pin :tclk
-        add_pin :tdi
-        add_pin :tdo
-        add_pin :tms
-        add_pin :pa0
-        add_pin :pa1
-        add_pin :pa2
-        add_pin_group :pa, :pa2, :pa1, :pa0
-        add_pin_alias :tdi_a, :tdi
-        # add_pin_group :jtag, :tdi, :tdo, :tms
-        add_power_pin_group :vdd1
-        add_power_pin_group :vdd2
-        add_virtual_pin :virtual1, type: :virtual_pin
-        add_virtual_pin :virtual2, type: :ate_ch
-
-        reg :testme32, 0x007a do |reg|
-          reg.bits 31..16, :portB
-          reg.bits 15..8,  :portA
-          reg.bits 1,      :done
-          reg.bits 0,      :enable
-        end
-        @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',
-                    onemodsub: false        # whether to expects subr to be in single module
-                }.merge(options)
-
-        if options[:define]
-          # define subroutine
-          $tester.start_subroutine(options[:name], onemodsub: options[:onemodsub])
-          $tester.cycle
-          $tester.end_subroutine(onemodsub: options[:onemodsub])
-          $tester.cycle unless options[:onemodsub]
-        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 digsrc_overlay(options = {})
-        options = { define:            false,       # whether to define subr or call it
-                    subr_name:         false,       # default use match type as subr name
-                    digsrc_pins:       @digsrc_pins, # defaults to what's defined in $dut
-                    overlay_reg:       nil, # defaults to testme32 register
-                    overlay_cycle_num: 32, # Only needed if overlay_reg is NOT nil, this specificies how many clk cycles to overlay.
-                }.merge(options)
-        if options[:define]
-          $tester.start_subroutine(options[:subr_name]) # Start subroutine
-          digsrc_pins = $tester.assign_digsrc_pins(options[:digsrc_pins])
-          $tester.digsrc_start(digsrc_pins, dssc_mode: :single)
-          original_pin_states = {}
-          digsrc_pins.each do |pin|
-            original_pin_states.merge!(pin => pin(pin).data)
-            pin(pin).drive_mem
-          end
-          if options[:overlay_reg].nil?
-            options[:overlay_cycle_num].times do
-              $tester.digsrc_send(digsrc_pins)
-              $tester.cycle
-            end
-          else
-            $tester.dont_compress = true
-            options[:overlay_reg].size.times do
-              $tester.digsrc_send(digsrc_pins)
-              $tester.cycle
-            end
-          end
-          original_pin_states.each do |pin, state|
-            pin(pin).drive(state)
-          end
-          $tester.digsrc_stop(digsrc_pins)
-          $tester.cycle
-          $tester.end_subroutine # end subroutine
-        else
-          $tester.cycle
-          $tester.call_subroutine(options[:subr_name])
-        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
-
-      def freq_count(options = {})
-        options = {
-        }.merge(options)
-
-        $tester.freq_count($dut.pin(:tdo), readcode: 73)
-      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
+module OrigenTesters
+  module Test
+    class DUT3
+      # Simple DUT using Nexus interface
+
+      attr_accessor :blocks
+      attr_accessor :hv_supply_pin
+      attr_accessor :lv_supply_pin
+      attr_accessor :digsrc_pins
+      attr_accessor :digcap_pins
+      attr_accessor :digsrc_settings
+      attr_accessor :digcap_settings
+
+      include OrigenARMDebug
+      include Origen::TopLevel
+      include OrigenJTAG
+
+      def initialize(options = {})
+        add_pin :tclk
+        add_pin :tdi
+        add_pin :tdo
+        add_pin :tms
+        add_pin :pa0
+        add_pin :pa1
+        add_pin :pa2
+        add_pin_group :pa, :pa2, :pa1, :pa0
+        add_pin_alias :tdi_a, :tdi
+        # add_pin_group :jtag, :tdi, :tdo, :tms
+        add_power_pin_group :vdd1
+        add_power_pin_group :vdd2
+        add_virtual_pin :virtual1, type: :virtual_pin
+        add_virtual_pin :virtual2, type: :ate_ch
+
+        reg :testme32, 0x007a do |reg|
+          reg.bits 31..16, :portB
+          reg.bits 15..8,  :portA
+          reg.bits 1,      :done
+          reg.bits 0,      :enable
+        end
+        @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',
+                    onemodsub: false        # whether to expects subr to be in single module
+                }.merge(options)
+
+        if options[:define]
+          # define subroutine
+          $tester.start_subroutine(options[:name], onemodsub: options[:onemodsub])
+          $tester.cycle
+          $tester.end_subroutine(onemodsub: options[:onemodsub])
+          $tester.cycle unless options[:onemodsub]
+        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 digsrc_overlay(options = {})
+        options = { define:            false,       # whether to define subr or call it
+                    subr_name:         false,       # default use match type as subr name
+                    digsrc_pins:       @digsrc_pins, # defaults to what's defined in $dut
+                    overlay_reg:       nil, # defaults to testme32 register
+                    overlay_cycle_num: 32, # Only needed if overlay_reg is NOT nil, this specificies how many clk cycles to overlay.
+                }.merge(options)
+        if options[:define]
+          $tester.start_subroutine(options[:subr_name]) # Start subroutine
+          digsrc_pins = $tester.assign_digsrc_pins(options[:digsrc_pins])
+          $tester.digsrc_start(digsrc_pins, dssc_mode: :single)
+          original_pin_states = {}
+          digsrc_pins.each do |pin|
+            original_pin_states.merge!(pin => pin(pin).data)
+            pin(pin).drive_mem
+          end
+          if options[:overlay_reg].nil?
+            options[:overlay_cycle_num].times do
+              $tester.digsrc_send(digsrc_pins)
+              $tester.cycle
+            end
+          else
+            $tester.dont_compress = true
+            options[:overlay_reg].size.times do
+              $tester.digsrc_send(digsrc_pins)
+              $tester.cycle
+            end
+          end
+          original_pin_states.each do |pin, state|
+            pin(pin).drive(state)
+          end
+          $tester.digsrc_stop(digsrc_pins)
+          $tester.cycle
+          $tester.end_subroutine # end subroutine
+        else
+          $tester.cycle
+          $tester.call_subroutine(options[:subr_name])
+        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
+
+      def freq_count(options = {})
+        options = {
+        }.merge(options)
+
+        $tester.freq_count($dut.pin(:tdo), readcode: 73)
+      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