origen_testers 0.4.0

data/pattern/nvm/v93k/v93k_workout.rb

@@ -0,0 +1,136 @@
+Pattern.create do
+
+  ss "Test that basic cycling works"
+  $tester.cycle
+  10.times do
+    $nvm.pin(:invoke).drive(1)
+    $tester.cycle
+  end
+  10.times do |i|
+    $nvm.pin(:invoke).drive(i.even? ? 0 : 1)
+    $tester.cycle
+  end
+
+  ss "Test that the port API works"
+  $nvm.port(:porta).drive(0x55)
+  $tester.cycle
+  $nvm.port(:porta).expect(0xAA)
+  $tester.cycle
+  $nvm.port(:porta).drive!(0x55)
+  $nvm.port(:porta).dont_care!
+  $nvm.port(:porta).drive_hi!
+  $nvm.port(:porta).drive_very_hi!
+  $nvm.port(:porta).drive_lo!
+  $nvm.port(:porta).assert_hi!
+  $nvm.port(:porta).assert_lo!
+  $nvm.port(:porta).drive_lo
+
+  ss "Test that the store method works"
+  cc "This vector should capture the FAIL pin data"
+  $tester.cycle
+  $tester.store $nvm.pin(:fail)
+  $tester.cycle
+  cc "This vector should capture the FAIL pin and the PORTA data"
+  $tester.cycle
+  $tester.cycle
+  $tester.cycle
+  $tester.store $nvm.pin(:fail), $nvm.port(:porta), :offset => -2
+  $tester.cycle
+  $tester.store_next_cycle $nvm.pin(:fail)
+  cc "This vector should capture the FAIL pin data"
+  $tester.cycle
+
+  ss "Test calling a subroutine"
+  cc "This vector should call subroutine 'sub1'"
+  $tester.cycle
+  $tester.call_subroutine("sub1")
+  cc "This vector should call subroutine 'sub2'"
+  $tester.cycle
+  $tester.cycle
+  $tester.call_subroutine("sub2", :offset => -1)
+
+#  ss "Test generating a handshake inside a subroutine"
+#  cc "The next line should have a global label 'sub3', but no vector"
+#  $tester.start_subroutine("sub3")
+#  $tester.handshake
+#  cc "This vector should have a return statement"
+#  $tester.cycle
+#  $tester.end_subroutine
+#
+#  ss "Test generating a handshake with a readcode"
+#  $tester.handshake(:readcode => 10)
+#
+#  ss "Test frequency counter"
+#  $tester.freq_count($nvm.pin(:dtst), :readcode => 33)
+
+  ss "Test a single pin match loop"
+  $tester.wait(:match => true, :time_in_us => 5000, :pin => $nvm.pin(:done), :state => :high)
+
+  ss "Test a two pin match loop"
+  $tester.wait(:match => true, :time_in_us => 5000,
+               :pin => $nvm.pin(:done), :state => :high,
+               :pin2 => $nvm.pin(:fail), :state2 => :low)
+  $nvm.pin(:fail).assert(0)
+
+  ss "Test looping, these vectors should be executed once"
+  $tester.loop_vector("test_loop_1", 1) do
+    $nvm.port(:porta).drive(0xAA)
+    $tester.cycle
+    $nvm.port(:porta).drive(0x55)
+    $tester.cycle
+  end
+
+  ss "Test looping, these vectors should be executed 3 times"
+  $tester.loop_vector("test_loop_2", 3) do
+    $nvm.port(:porta).drive(0xAA)
+    $tester.cycle
+    $nvm.port(:porta).drive(0x55)
+    $tester.cycle
+  end
+
+  ss "Test looping, these vectors should be executed 5 times"
+  $tester.loop_vectors 5 do
+    $nvm.port(:porta).drive(0xAA)
+    $tester.cycle
+    $nvm.port(:porta).drive(0x55)
+    $tester.cycle
+  end
+
+#  ss "Test repeat_previous"
+#  $tester.cycle
+#  cc "Invoke should repeat previous for 10 cycles"
+#  $nvm.pin(:invoke).repeat_previous = true
+#  10.cycles
+#  $nvm.pin(:invoke).repeat_previous = false
+#  cc "All pins should repeat previous for 10 cycles, except the clk pin"
+#  $tester.repeat_previous do
+#    $nvm.pin(:clk).drive(1)
+#    10.cycles
+#  end
+#  cc "All should return to the original state"
+#  $tester.cycle
+
+  ss "Test suspend compares"
+  $nvm.pin(:fail).assert!(1)
+  cc "The fail pin should not be compared on these vectors"
+  $tester.ignore_fails($nvm.pin(:fail)) do
+    10.cycles
+  end
+  cc "And now it should"
+  $tester.cycle
+
+  ss "Test inhibit vectors and comments"
+  cc "The invoke pin should be driving high on this cycle"
+  $nvm.pin(:invoke).drive!(1)
+  cc "This should be the last thing you see until 'Inhibit complete!'"
+  $tester.inhibit_vectors_and_comments do
+    cc "This should not be in the output file, or the following vectors"
+    $tester.cycle
+    $nvm.pin(:invoke).drive!(0)
+    10.cycles
+  end
+  cc "Inhibit complete!"
+  cc "The invoke pin should be driving low on this cycle"
+  $tester.cycle
+
+end

data/pattern/read_write_reg.rb

@@ -0,0 +1,58 @@
+# Pattern to exercise the reading and writing of a register using ARM Debug
+Pattern.create do
+  ss 'Test write register with all 1s'
+  $dut.reg(:testme32).write!(0xFFFFFFFF)
+  ss 'Test read register after all 1s write'
+  $dut.reg(:testme32).read!
+
+  ss 'Test write register with all 0s'
+  $dut.reg(:testme32).write!(0x00000000)
+  ss 'Test read register after all 0s write'
+  $dut.reg(:testme32).read!
+
+  ss 'Test store register, the whole register data should be stored'
+  $dut.reg(:testme32).store!
+
+  ss 'Test store bits, only enable bit should be captured'
+  $dut.reg(:testme32).bit(:enable).store!
+
+  ss 'Test store bits, only port A should be captured'
+  $dut.reg(:testme32).bits(:portA).store!
+
+  ss 'Test read of partial register, only portA should be read'
+  $dut.reg(:testme32).bits(:portB).read!
+
+  ss 'Test overlay, all reg vectors should be from subroutine'
+  $dut.reg(:testme32).overlay('write_overlay')
+  $dut.reg(:testme32).write!
+
+  ss 'Test overlay, same again but for read'
+  $dut.reg(:testme32).overlay('read_overlay')
+  $dut.reg(:testme32).read!
+
+  ss 'Test bit level write overlay, only portA should be from subroutine'
+  $dut.reg(:testme32).overlay(nil)  # have to reset overlay bits as they are sticky from last overlay set
+  $dut.reg(:testme32).bits(:portA).overlay('write_overlay')
+  $dut.reg(:testme32).bits(:portA).write!
+
+  ss 'Test bit level read overlay, only portA should be from subroutine'
+  $dut.reg(:testme32).overlay(nil)
+  $dut.reg(:testme32).bits(:portA).overlay('read_overlay')
+  $dut.reg(:testme32).bits(:portA).read!
+
+  ss 'Call execute subroutine'
+  $dut.execute
+
+  ss 'Call match_pin subroutine'
+  $dut.match(:type => :match_pin)
+
+  ss 'Call match_2pins subroutine'
+  $dut.match(:type => :match_2pins)
+
+  ss 'Call match_done subroutine'
+  $dut.match(:type => :match_done)
+
+  ss 'Call handshake subroutine'
+  $dut.handshake
+
+end

data/pattern/reset.rb

@@ -0,0 +1,4 @@
+# Pattern to exercise the reading and writing of a register using Nexus
+Pattern.create do
+  $dut.reset
+end

data/pattern/subroutines.rb

@@ -0,0 +1,38 @@
+unless $tester.v93k?
+  # Pattern to define subroutines
+  if $tester.respond_to?('start_subroutine')
+    Pattern.create(:subroutine_pat => true) do
+
+      # Define execute subr
+      $dut.execute(:define => true)
+
+      # Define match_pin
+      $dut.match(:define => true, :type => :match_pin)
+
+      # Define match_2pins
+      $dut.match(:define => true, :type => :match_2pins)
+
+      # Define match_done subr
+      $dut.match(:define => true, :type => :match_done, :delay_in_us => 5)
+
+      # Define match_done subr with longer timeout of 7mS
+      $dut.match(:subr_name => 'match_done2', :define => true, :type => :match_done, :delay_in_us => 7000)
+
+      # Define match_done subr with longer timeout of 7sec
+      $dut.match(:subr_name => 'match_done3', :define => true, :type => :match_done, :delay_in_us => 7000000)
+
+      # Define match_done subr with longer timeout of 72sec
+      $dut.match(:subr_name => 'match_done4', :define => true, :type => :match_done, :delay_in_us => 72_000_000)
+
+      # Define match_done subr with longer timeout of 10min
+      $dut.match(:subr_name => 'match_done5', :define => true, :type => :match_done, :delay_in_us => 7_000_000_000)
+
+      # Define match loop with multiple entries
+      $dut.match(:subr_name => 'match_done6', :define => true, :type => :multiple_entries, :delay_in_us => 15_000_000)
+
+      # Define handshake subr
+      $dut.handshake(:define => true)
+
+    end
+  end
+end

data/program/_additional_erase.rb

@@ -0,0 +1,7 @@
+Flow.create do |options|
+
+  if_enable 'additional_erase', :or => options[:force] do
+    func :erase_all
+  end
+
+end

data/program/_efa_resources.rb

@@ -0,0 +1,7 @@
+Resources.create do |options|
+
+  func :bitmap_all0
+
+  import 'iv_resources', :number => 3
+
+end

data/program/_erase.rb

@@ -0,0 +1,25 @@
+# A sub flow is a flow like any other.
+# However the name should begin with
+# _ to indicate that it is a sub
+# flow  this will prevent it being
+# generated as a top-level flow by
+# Origen.
+# Any arguments passed in when
+# instantiating this flow will be available via a hash as the second
+# argument, here called options, although the naming is arbitrary.
+Flow.create do |options|
+
+  # Define default options
+  options = { :pulses      => 4,
+              :post_verify => true,
+  }.merge(options)
+
+  options[:pulses].times do
+    func :erase_all
+  end
+
+  if options[:post_verify]
+    import 'erase_vfy'
+  end
+
+end

data/program/_erase_vfy.rb

@@ -0,0 +1,5 @@
+Flow.create do |options|
+
+  func :margin_read1_all1
+
+end

data/program/_iv_resources.rb

@@ -0,0 +1,10 @@
+Resources.create do |options|
+
+  options = { :number => 2,
+  }.merge(options)
+
+  options[:number].times do |x|
+    func "bitcell_iv_#{x}"
+  end
+
+end

data/program/basic_interface.rb

@@ -0,0 +1,5 @@
+Flow.create interface: 'OrigenTesters::Test::BasicInterface' do
+
+  functional :test1, sbin: 100
+
+end

data/program/components/_prb2_main.rb

@@ -0,0 +1,6 @@
+Flow.create do |options|
+
+  func :pgm_ckbd
+  func :mrd_ckbd
+
+end

data/program/flow_control.rb

@@ -0,0 +1,164 @@
+# Flow to exercise the Flow Control API
+#
+# Some of the other flows also cover the flow control API and those tests are used
+# to guarantee that the test ID references work when sub-flows are involved.
+# This flow provides a full checkout of all flow control methods.
+Flow.create do
+
+  self.resources_filename = 'flow_control'
+
+  log "Test that if_failed works"
+  func :read1, id: :t1, bin: 10
+  func :erase1, if_failed: :t1, bin: 12
+
+  log "Test the block form of if_failed"
+  func :read2, id: :t2, bin: 10
+  if_failed :t2 do
+    func :erase2
+    func :erase2
+  end
+
+  log "Test that if_passed works"
+  func :read1, id: :t3, bin: 10
+  func :pgm1, if_passed: :t3
+
+  log "Test the block form of if_passed"
+  func :read2, id: :t4, bin: 10
+  if_passed :t4 do
+    func :pgm1
+    func :pgm1
+  end
+
+  log "Test that if_ran works"
+  func :pgm, id: :t5, bin: 10
+  func :read0, if_ran: :t5
+
+  log "Test the block form of if_ran"
+  func :pgm, id: :t6, bin: 10
+  if_ran :t6 do
+    func :read0
+    func :read0
+  end
+
+  log "Test that unless_ran works"
+  func :pgm, id: :t7, bin: 10
+  func :read0, unless_ran: :t7
+
+  log "Test the block form of unless_ran"
+  func :pgm, id: :t8, bin: 10
+  unless_ran :t8 do
+    func :read0
+    func :read0
+  end
+
+  log "Test that skip works"
+  skip do
+    func :read0
+    func :read0
+  end
+
+  log "Test that conditional skip works"
+  skip if_passed: :t4 do
+    func :read0
+    func :read0
+  end
+
+  log "Test that if_job works"
+  func :cold_test, if_job: :fc
+
+  log "Test the block form of if_job"
+  if_job [:prb1, :prb2] do
+    func :probe_only_test1
+    func :probe_only_test2
+  end
+
+  log "Test that unless_job works"
+  func :warmish_test, unless_job: :fc
+
+  log "Test the block form of unless_job"
+  unless_job [:prb1, :prb2] do
+    func :ft_only_test1
+    func :ft_only_test2
+  end
+
+  log "Test that if_enable works"
+  func :extra_test, if_enable: :extras
+
+  log "Test the block form of if_enable"
+  if_enable :cz do
+    func :cz_test1
+    func :cz_test2
+  end
+
+  log "Test that unless_enable works"
+  func :long_test, unless_enable: :quick
+
+  log "Test the block form of unless_enable"
+  unless_enable :quick do
+    func :long_test1
+    func :long_test2
+  end
+
+  if $tester.v93k?
+    log "Test that an id can be assigned to a test group"
+    func :read1, id: :r1, bin: 10, by_block: true
+    func :erase1, if_failed: :r1
+
+    log "Test that group-level dependencies work"
+    group "grp1", id: :grp1 do
+      func :grp1_test1, bin: 5
+      func :grp1_test2, bin: 5
+      func :grp1_test3, bin: 5
+    end
+
+    group "grp2", if_failed: :grp1 do
+      func :grp2_test1, bin: 5
+      func :grp2_test2, bin: 5
+      func :grp2_test3, bin: 5
+    end
+
+    log "Another group-level dependencies test based on a real life use case"
+    func :gt1, bin: 90
+    group "gt_grp1", id: :gt_grp1 do
+      func :gt_grp1_test1, bin: 90, id: :gt_grp1
+      func :gt_grp1_test2, bin: 90, id: :gt_grp1
+    end
+    func :gt2, bin: 90, if_failed: :gt_grp1
+    group "gt_grp2", id: :gt_grp2, if_failed: :gt_grp1 do
+      # The if_failed and IDs here are redundant, but it should still generate
+      # valid output if an application were to do this
+      func :gt_grp2_test1, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+      func :gt_grp2_test2, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+    end
+    func :gt3, bin: 90, if_failed: :gt_grp2
+
+    log "Test that nested groups work"
+    group "level1" do
+      func :lev1_test1, bin: 5
+      func :lev1_test2, bin: 5
+      func :lev1_test3, id: :l1t3, bin: 10
+      func :lev1_test4, if_failed: :l1t3, bin: 12
+      func :lev1_test5, id: :l1t5, bin: 12
+      group "level2" do
+        func :lev2_test1, bin: 5
+        func :lev2_test2, bin: 5
+        func :lev2_test3, id: :l2t3, bin: 10
+        func :lev2_test4, if_failed: :l2t3, bin: 12
+        # Test dependency on a test from another group
+        func :lev2_test5, if_failed: :l1t5, bin: 12
+      end
+    end
+
+    log "Test nested conditions on a group"
+    func :nt1, bin: 10, id: :nt1
+    if_failed :nt1 do
+      func :nt2, bin: 11, id: :nt2
+      group "ntg1", id: :ntg1, if_passed: :nt2 do
+        func :nt3, bin: 12
+      end
+      group "ntg2", id: :ntg2, if_failed: :nt2 do
+        func :nt4, bin: 13
+      end
+    end
+  end
+end