origen_link 0.1.0.pre0 → 0.1.0

data/lib/origen_link/{includes_vector_based.rb → server_com.rb}

@@ -1,7 +1,5 @@
 module OrigenLink
-  class VectorBased
-    include OrigenTesters::VectorBasedTester
-
+  module ServerCom
     # send_cmd(cmdstr, argstr)
     #   cmdstr is a valid command.  <category>_<command>
     #     Ex: 'pin_assign'
@@ -29,7 +27,7 @@ module OrigenLink
       # open a connection to the server, send the command and wait for a response
       TCPSocket.open(@address, @port) do |link|
         t2 = Time.now
-        link.puts(cmdstr + ':' + argstr)
+        link.write(cmdstr + ':' + argstr + "\n\n")
         t3 = Time.now
         response = link.gets
         t4 = Time.now
@@ -46,8 +44,35 @@ module OrigenLink
       @total_recv_time += (t4 - t3)
       @max_receive_time = (t4 - t3) if @max_receive_time < (t4 - t3)
       @total_packets += 1
-      Origen.log.error 'nil reponse from server (likely died) for command(' + cmdstr + ':' + argstr + ')' if response.nil?
-      response	# ensure the response is passed along
+      Origen.log.error 'nil response from server (likely died) for command(' + cmdstr + ':' + argstr + ')' if response.nil?
+      response    # ensure the response is passed along
+    end
+
+    def send_batch(vector_batch)
+      t2 = 0
+      t3 = 0
+      t4 = 0
+      t5 = 0
+      response = []
+      t1 = Time.now
+      TCPSocket.open(@address, @port) do |link|
+        t2 = Time.now
+        vector_batch_str = vector_batch.join("\n") + "\n\n"
+        link.write(vector_batch_str)
+        t3 =  Time.now
+        while line = link.gets
+          response << line.chomp
+        end
+        t4 = Time.now
+      end
+      t5 = Time.now
+      @total_comm_time += (t5 - t1)
+      @total_connect_time += (t2 - t1)
+      @total_xmit_time += (t3 - t2)
+      @total_recv_time += (t4 - t3)
+      @max_receive_time = (t4 - t3) if @max_receive_time < (t4 - t3)
+      @total_packets += 1
+      response
     end
 
     # setup_cmd_response_logger
@@ -60,7 +85,7 @@ module OrigenLink
         # if the server died (which hopefully it never will) response is nil
         case response.chr
         when 'P'
-          Origen.log.info command + ' setup was successful'
+          Origen.log.debug command + ' setup was successful'
         when 'F'
           Origen.log.error command + ' setup FAILED with the following message:'
           Origen.log.error response.chomp

data/lib/origen_link/test/top_level.rb

@@ -0,0 +1,48 @@
+module OrigenLink
+  module Test
+    class TopLevel
+      include Origen::TopLevel
+
+      def initialize(options = {})
+        instantiate_pins(options)
+        instantiate_registers(options)
+        instantiate_sub_blocks(options)
+      end
+
+      def instantiate_pins(options = {})
+        options = {
+          jtag_comm_config:			     false,
+          invalid_pin_number_test:	false,
+          missing_pinmap_test:		   false
+        }.merge(options)
+        add_pin :tclk
+        add_pin :tdi
+        add_pin :tdo
+        add_pin :tms
+        add_pin :resetb
+        add_pins :port_a, size: 8
+
+        pin_pattern_order :tclk, :tms, :tdi, :tdo, only: true if options[:jtag_comm_config]
+
+        # if tester.link? #.to_s == 'OrigenLink::VectorBased'
+        if tester.to_s == 'OrigenLink::VectorBased'
+          if options[:invalid_pin_number_test]
+            tester.pinmap = 'tclk,119,tms,1900,tdi,116,tdo,124'
+          else
+            tester.pinmap = 'tclk,119,tms,6,tdi,116,tdo,124' unless options[:missing_pinmap_test]
+          end
+          tester.pinorder = 'tclk,tms,tdi,tdo'
+        end
+      end
+
+      def instantiate_registers(options = {})
+        reg :testreg, 0 do |reg|
+          reg.bits 31..0,		:value
+        end
+      end
+
+      def instantiate_sub_blocks(options = {})
+      end
+    end
+  end
+end

data/lib/origen_link/test/top_level_controller.rb

@@ -0,0 +1,44 @@
+module OrigenLink
+  module Test
+    class TopLevelController
+      include Origen::Controller
+
+      include OrigenJTAG
+
+      JTAG_CONFIG = {
+        #:tclk_format => :rl,
+        tclk_format:     :rh,
+        #:tclk_multiple => 1,
+        tclk_multiple:   4,
+        tdo_strobe:      :tclk_high,
+        tdo_store_cycle: 3,
+        init_state:      :idle
+      }
+
+      def startup(options)
+        pp 'Enter test mode' do
+          # if tester.link?
+          if tester.to_s == 'OrigenLink::VectorBased'
+            tester.initialize_pattern
+            # below is for testing return format timing, requires tclk to be rl and multiple of 1
+            # tester.pinformat = 'func_25mhz,tclk,rl'
+            # tester.pintiming = 'func_25mhz,tdi,0,tms,0,tdo,1'
+          end
+          tester.set_timeset('func_25mhz', 40)   # Where 40 is the period in ns
+          tester.wait time_in_us: 100
+        end
+      end
+
+      def shutdown(options)
+        pp 'Reset the device' do
+          pin(:resetb).drive!(0)
+          pin(:tclk).drive!(0)
+        end
+        # if tester.link?
+        if tester.to_s == 'OrigenLink::VectorBased'
+          tester.finalize_pattern
+        end
+      end
+    end
+  end
+end

data/lib/origen_link/test/vector_based.rb

@@ -0,0 +1,25 @@
+require 'origen_link/vector_based'
+
+module OrigenLink
+  module Test
+    class VectorBased < ::OrigenLink::VectorBased
+      attr_accessor :message, :microcodestr, :test_response
+
+      def send_cmd(cmdstr, argstr)
+        @message = cmdstr + ':' + argstr
+        @test_response
+      end
+
+      def send_batch(vector_batch)
+        @test_response
+      end
+
+      def setup_cmd_response_logger(command, response)
+      end
+
+      def microcode(msg)
+        @microcodestr = @microcodestr + msg
+      end
+    end
+  end
+end

data/lib/origen_link/vector_based.rb

@@ -1,3 +1,6 @@
+require 'origen_testers'
+require 'origen_link/server_com'
+require 'origen_link/callback_handlers'
 module OrigenLink
   # OrigenLink::VectorBased
   #   This class is meant to be used for live silicon debug.  Vector data that Origen
@@ -9,15 +12,15 @@ module OrigenLink
   # Integration instructions
   #   Set the pin map (must be done first) and pin order
   #     if tester.link?
-  #	    tester.pinmap = 'tclk,26,tms,19,tdi,16,tdo,23'
-  #		tester.pinorder = 'tclk,tms,tdi,tdo'
+  #        tester.pinmap = 'tclk,26,tms,19,tdi,16,tdo,23'
+  #        tester.pinorder = 'tclk,tms,tdi,tdo'
   #     end
   #
   #   Set Origen to only generate vectors for pins in the pinmap (order should match)
-  #  	  pin_pattern_order :tclk, :tms, :tdi, :tdo, only: true if tester.link?
+  #        pin_pattern_order :tclk, :tms, :tdi, :tdo, only: true if tester.link?
   #
   #   At the beginning of the Startup method add this line
-  #	  tester.initialize_pattern if tester.link?
+  #      tester.initialize_pattern if tester.link?
   #
   #   At the end of the Shutdown method add this line
   #     tester.finalize_pattern if tester.link?
@@ -25,12 +28,15 @@ module OrigenLink
   #   Create a link environment with the IP address and socket number of a link server
   #     $tester = OrigenLink::VectorBased.new('192.168.0.2', 12777)
   class VectorBased
-    # include OrigenTesters::VectorBasedTester
+    include OrigenTesters::VectorBasedTester
+    include ServerCom
 
     # these attributes are exposed for testing purposes, a user would not need to read them
-    attr_reader :fail_count, :vector_count, :total_comm_time, :total_connect_time, :total_xmit_time, :total_recv_time, :total_packets, :vector_repeatcount, :tsets_programmed
+    attr_reader :fail_count, :vector_count, :total_comm_time, :total_connect_time, :total_xmit_time
+    attr_reader :total_recv_time, :total_packets, :vector_repeatcount, :tsets_programmed, :captured_data
+    attr_reader :vector_batch, :store_pins_batch, :comment_batch
 
-    def initialize(address, port)
+    def initialize(address, port, options = {})
       @address = address
       @port = port
       @fail_count = 0
@@ -47,16 +53,47 @@ module OrigenLink
       @max_receive_time = 0
       @tsets_programmed = {}
       @tset_count = 1
+      @store_pins = []
+      @captured_data = []
+      # A tester seems to be unable to register as a callback handler, so for now instantiating a
+      # dedicated object to implement the handlers related to this tester
+      CallbackHandlers.new
+      @vector_batch = []
+      @store_pins_batch = {}
+      @comment_batch = {}
+      @batch_vectors = true
+    end
+
+    # push_comment
+    #   This method intercepts comments so they can be correctly placed in the output file
+    #   when vector batching is used
+    def push_comment(msg)
+      if @batch_vectors
+        key = @vector_batch.length
+        if @comment_batch.key?(key)
+          @comment_batch[key] = @comment_batch[key] + "\n" + msg
+        else
+          @comment_batch[key] = msg
+        end
+      else
+        microcode msg
+      end
     end
 
     # push_vector
     #   This method intercepts vector data from Origen, removes white spaces and compresses repeats
     def push_vector(options)
       programmed_data = options[:pin_vals].gsub(/\s+/, '')
+      unless options[:timeset]
+        puts 'No timeset defined!'
+        puts 'Add one to your top level startup method or target like this:'
+        puts '$tester.set_timeset("nvmbist", 40)   # Where 40 is the period in ns'
+        exit 1
+      end
       tset = options[:timeset].name
       if @vector_count > 0
         # compressing repeats as we go
-        if (programmed_data == @previous_vectordata) && (@previous_tset == tset)
+        if (programmed_data == @previous_vectordata) && (@previous_tset == tset) && @store_pins.empty?
           @vector_repeatcount += 1
         else
           # all repeats of the previous vector have been counted
@@ -74,6 +111,65 @@ module OrigenLink
       @vector_count += 1
     end
 
+    # Capture a vector
+    #
+    # This method applies a store vector request to the previous vector, note that is does
+    # not actually generate a new vector.
+    #
+    # The captured data is added to the captured_data array.
+    #
+    # This method is indended to be used by pin drivers, see the #capture method for the application
+    # level API.
+    #
+    # @example
+    #   $tester.cycle                # This is the vector you want to capture
+    #   $tester.store                # This applies the store request
+    def store(*pins)
+      options = pins.last.is_a?(Hash) ? pins.pop : {}
+      fail 'The store is not implemented yet on Link'
+    end
+
+    # Capture the next vector generated
+    #
+    # This method applies a store request to the next vector to be generated,
+    # note that is does not actually generate a new vector.
+    #
+    # The captured data is added to the captured_data array.
+    #
+    # This method is indended to be used by pin drivers, see the #capture method for the application
+    # level API.
+    #
+    # @example
+    #   tester.store_next_cycle
+    #   tester.cycle                # This is the vector that will be captured
+    def store_next_cycle(*pins)
+      options = pins.last.is_a?(Hash) ? pins.pop : {}
+      flush_vector
+      @store_pins = pins
+    end
+
+    # Capture any store data within the given block, return it and then internally clear the tester's
+    # capture memory.
+    #
+    # @example
+    #
+    #   v = tester.capture do
+    #     my_reg.store!
+    #   end
+    #   v      # => Data value read from my_reg on the DUT
+    def capture(*args)
+      if block_given?
+        yield
+        synchronize
+        d = @captured_data
+        @captured_data = []
+        d
+      else
+        # On other testers capture is an alias of store
+        store(*args)
+      end
+    end
+
     # flush_vector
     #   Just as the name suggests, this method "flushes" a vector.  This is necessary because
     #   of repeat compression (a vector isn't sent until different vector data is encountered)
@@ -81,36 +177,116 @@ module OrigenLink
     #   Don't forget to flush when you're in debug mode.  Otherwise, the last vector of a
     #   write command won't be sent to the server.
     def flush_vector(programmed_data = '', tset = '')
-      if @vector_repeatcount > 1
-        repeat_prefix = "repeat#{@vector_repeatcount},"
+      # prevent server crash when vector_flush is used during debug
+      unless @previous_vectordata == ''
+        if @vector_repeatcount > 1
+          repeat_prefix = "repeat#{@vector_repeatcount},"
+        else
+          repeat_prefix = ''
+        end
+        if @tsets_programmed[@previous_tset]
+          tset_prefix = "tset#{@tsets_programmed[@previous_tset]},"
+        else
+          tset_prefix = ''
+        end
+
+        if @batch_vectors
+          @vector_batch << 'pin_cycle:' + tset_prefix + repeat_prefix + @previous_vectordata
+          # store capture pins for batch processing
+          unless @store_pins.empty?
+            @store_pins_batch[@vector_batch.length - 1] = @store_pins
+          end
+        else
+          process_vector_response(send_cmd('pin_cycle', tset_prefix + repeat_prefix + @previous_vectordata))
+        end
+
+        # make sure that only requested vectors are stored when batching is enabled
+        @store_pins = []
+      end
+
+      @vector_repeatcount = 1
+      @previous_vectordata = programmed_data
+      @previous_tset = tset
+    end
+
+    # synchronize
+    #   This method will synchronize the DUT state with Origen.  All generated
+    #   vectors are sent to the DUT for execution and the responses are processed
+    def synchronize(output_file = '')
+      flush_vector
+      if @batch_vectors
+        process_response(send_batch(@vector_batch), output_file)
+      end
+      @vector_batch = []
+      @store_pins_batch.clear
+      @comment_batch.clear
+    end
+
+    # process_response
+    #   This method will process a server response.  Send log info to the output,
+    #   keep track of fail count and captured data
+    def process_response(response, output_file = '')
+      if response.is_a?(Array)
+        # if called from finalize_pattern -> synchronize, open the output_file and store results
+        output_obj = nil
+        output_obj = File.open(output_file, 'a+') unless output_file == ''
+        response.each_index do |index|
+          # restore store pins state for processing
+          if @store_pins_batch.key?(index)
+            @store_pins = @store_pins_batch[index]
+          else
+            @store_pins = []
+          end
+          if @comment_batch.key?(index)
+            unless output_file == ''
+              # get the header placed correctly
+              if index == response.length - 1
+                output_obj.puts 'last comment'
+                output_obj.lineno = 0
+              end
+              output_obj.puts(@comment_batch[index])
+            end
+          end
+          process_vector_response(response[index], output_obj)
+        end
+        output_obj.close unless output_file == ''
       else
-        repeat_prefix = ''
+        process_vector_response(response)
       end
-      if @tsets_programmed[@previous_tset]
-        tset_prefix = "tset#{@tsets_programmed[@previous_tset]},"
+    end
+
+    # process_vector_response
+    #   This method exists to prevent code duplication when handling an array of
+    #   batched responses versus a single response string.
+    def process_vector_response(vector_response, output_obj = nil)
+      unless @store_pins.empty?
+        msg = "  (Captured #{@store_pins.map(&:name).join(', ')})\n"
+        capture_data(vector_response)
+        vector_response.strip!
+        vector_response += msg
+      end
+      if output_obj.nil?
+        microcode vector_response
       else
-        tset_prefix = ''
+        output_obj.puts(vector_response)
       end
-      response = send_cmd('pin_cycle', tset_prefix + repeat_prefix + @previous_vectordata)
-      microcode response
-      unless response.chr == 'P'
-        microcode 'E:' + @previous_vectordata + ' //expected data for previous vector'
+
+      unless vector_response.chr == 'P'
+        # TODO: Put this back with an option to disable, based on a serial or parallel interface being used
+        # microcode 'E:' + @previous_vectordata + ' //expected data for previous vector'
         @fail_count += 1
       end
-      @vector_repeatcount = 1
-      @previous_vectordata = programmed_data
-      @previous_tset = tset
     end
 
     # initialize_pattern
-    #   At some point in the future this intialization should be done behind the
-    #   scenes without requiring the user to add code to the controller.
-    #
     #   This method sets initializes variables at the start of a pattern.
-    #   it should be called from the Startup method of the dut controller.
+    #   it is called automatically when pattern generation starts.
     def initialize_pattern
       @fail_count = 0
       @vector_count = 0
+      @vector_batch.delete_if { true }
+      @store_pins_batch.clear
+      @comment_batch.clear
 
       @total_packets = 0
       @total_comm_time = 0
@@ -121,35 +297,36 @@ module OrigenLink
       if @pinmap.nil?
         Origen.log.error('pinmap has not been setup, use tester.pinmap= to initialize a pinmap')
       else
-        Origen.log.info('executing pattern with pinmap:' + @pinmap.to_s)
+        Origen.log.debug('executing pattern with pinmap:' + @pinmap.to_s)
       end
     end
 
     # finalize_pattern
-    #   At some point in the future this finalization should be done behind the scenes.
-    #
     #   This method flushes the final vector.  Then, it logs success or failure of the
     #   pattern execution along with execution time information.
-    def finalize_pattern(programmed_data = '')
-      flush_vector(programmed_data)
+    def finalize_pattern(output_file)
+      Origen.log.debug('Pattern generation completed. Sending all stored vector data')
+      synchronize(output_file)
+      # for debug, report communication times
+      Origen.log.debug("total communication time: #{@total_comm_time}")
+      Origen.log.debug("total connect time: #{@total_connect_time}")
+      Origen.log.debug("total transmit time: #{@total_xmit_time}")
+      Origen.log.debug("total receive time: #{@total_recv_time}")
+      Origen.log.debug("total packets: #{@total_packets}")
+      Origen.log.debug("total time per packet: #{@total_comm_time / @total_packets}")
+      Origen.log.debug("connect time per packet: #{@total_connect_time / @total_packets}")
+      Origen.log.debug("transmit time per packet: #{@total_xmit_time / @total_packets}")
+      Origen.log.debug("receive time per packet: #{@total_recv_time / @total_packets}")
+      Origen.log.debug("max packet time: #{@max_packet_time}")
+      Origen.log.debug("max duration command - #{@longest_packet}")
+      Origen.log.debug("max receive time: #{@max_receive_time}")
       if @fail_count == 0
-        Origen.log.success("PASS - pattern execution passed (#{@vector_count} vectors pass)")
+        # Origen.log.success("PASS - pattern execution passed (#{@vector_count} vectors pass)")
+        Origen.app.stats.report_pass
       else
-        Origen.log.error("FAIL - pattern execution failed (#{@fail_count} failures)")
+        # Origen.log.error("FAIL - pattern execution failed (#{@fail_count} failures)")
+        Origen.app.stats.report_fail
       end
-      # for debug, report communication times
-      Origen.log.info("total communication time: #{@total_comm_time}")
-      Origen.log.info("total connect time: #{@total_connect_time}")
-      Origen.log.info("total transmit time: #{@total_xmit_time}")
-      Origen.log.info("total receive time: #{@total_recv_time}")
-      Origen.log.info("total packets: #{@total_packets}")
-      Origen.log.info("total time per packet: #{@total_comm_time / @total_packets}")
-      Origen.log.info("connect time per packet: #{@total_connect_time / @total_packets}")
-      Origen.log.info("transmit time per packet: #{@total_xmit_time / @total_packets}")
-      Origen.log.info("receive time per packet: #{@total_recv_time / @total_packets}")
-      Origen.log.info("max packet time: #{@max_packet_time}")
-      Origen.log.info('max duration command - ' + @longest_packet)
-      Origen.log.info("max receive time: #{@max_receive_time}")
     end
 
     # to_s
@@ -162,14 +339,6 @@ module OrigenLink
       'OrigenLink::VectorBased'
     end
 
-    # link?
-    #   returns true.
-    #
-    #   This method indicates to user code that link is the tester environment.
-    def link?
-      true
-    end
-
     # pinmap=
     #   This method is used to setup the pin map on the debugger device.
     #   The argument should be a string with <pin name>, <gpio #>, <pin name>
@@ -250,5 +419,37 @@ module OrigenLink
       end
       @tsets_programmed[name]
     end
+
+    private
+
+    def capture_data(response)
+      if @store_pins.size > 1
+        fail 'Data capture on multiple pins is not implemented yet'
+      else
+        captured_data[0] ||= 0
+        captured_data[0] = (captured_data[0] << 1) | extract_value(response, @store_pins[0])
+        @store_pins = []
+      end
+    end
+
+    def extract_value(response, pin)
+      v = response[index_of(pin) + 2]
+      if v == '`'
+        1
+      elsif v == '.'
+        0
+      else
+        fail "Failed to extract value for pin #{pin.name}, character in response is: #{v}"
+      end
+    end
+
+    # Returns the vector index (position) of the given pin
+    def index_of(pin)
+      i = @pinorder.split(',').index(pin.name.to_s)
+      unless i
+        fail "Data capture of pin #{pin.name} has been requested, but it has not been included in the Link pinmap!"
+      end
+      i
+    end
   end
 end