origen_link 0.1.0.pre0

data/lib/origen_link/vector_based.rb

@@ -0,0 +1,254 @@
+module OrigenLink
+  # OrigenLink::VectorBased
+  #   This class is meant to be used for live silicon debug.  Vector data that Origen
+  #   generates is intercepted and sent to a debug device (typically will be a Udoo
+  #   Neo - www.udoo.org).  The debug device can be any device that is able to serve
+  #   a TCP socket, recieve and interpret the command set used by this class and send
+  #   the expected responses.
+  #
+  # 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'
+  #     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?
+  #
+  #   At the beginning of the Startup method add this line
+  #	  tester.initialize_pattern if tester.link?
+  #
+  #   At the end of the Shutdown method add this line
+  #     tester.finalize_pattern if tester.link?
+  #
+  #   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
+
+    # 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
+
+    def initialize(address, port)
+      @address = address
+      @port = port
+      @fail_count = 0
+      @vector_count = 0
+      @previous_vectordata = ''
+      @previous_tset = ''
+      @vector_repeatcount = 0
+      @total_comm_time = 0
+      @total_connect_time = 0
+      @total_xmit_time = 0
+      @total_recv_time = 0
+      @total_packets = 0
+      @max_packet_time = 0
+      @max_receive_time = 0
+      @tsets_programmed = {}
+      @tset_count = 1
+    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+/, '')
+      tset = options[:timeset].name
+      if @vector_count > 0
+        # compressing repeats as we go
+        if (programmed_data == @previous_vectordata) && (@previous_tset == tset)
+          @vector_repeatcount += 1
+        else
+          # all repeats of the previous vector have been counted
+          # time to flush.  Don't panic though!  @previous_vectordata
+          # is what gets flushed.  programmed_data is passed as an
+          # arg to be set as the new @previous_vectordata
+          flush_vector(programmed_data, tset)
+        end
+      else
+        # if this is the first vector of the pattern, insure variables are initialized
+        @previous_vectordata = programmed_data
+        @previous_tset = tset
+        @vector_repeatcount = 1
+      end # if vector_count > 0
+      @vector_count += 1
+    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)
+    #
+    #   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},"
+      else
+        repeat_prefix = ''
+      end
+      if @tsets_programmed[@previous_tset]
+        tset_prefix = "tset#{@tsets_programmed[@previous_tset]},"
+      else
+        tset_prefix = ''
+      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'
+        @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.
+    def initialize_pattern
+      @fail_count = 0
+      @vector_count = 0
+
+      @total_packets = 0
+      @total_comm_time = 0
+      @total_connect_time = 0
+      @total_xmit_time = 0
+      @total_recv_time = 0
+
+      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)
+      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)
+      if @fail_count == 0
+        Origen.log.success("PASS - pattern execution passed (#{@vector_count} vectors pass)")
+      else
+        Origen.log.error("FAIL - pattern execution failed (#{@fail_count} failures)")
+      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
+    #   returns 'Origen::VectorBased'
+    #
+    #   This method at the moment is used for implementing code that runs only if the
+    #   environment is set to link vector based.  tester.link? will be used once the testers
+    #   plug in supports the method link?.
+    def to_s
+      '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>
+    #   <gpio #>, etc
+    #
+    #   example:
+    #     tester.pinmap = 'tclk,26,tms,19,tdi,16,tdo,23'
+    def pinmap=(pinmap)
+      @pinmap = pinmap.gsub(/\s+/, '')
+      response = send_cmd('pin_assign', @pinmap)
+      setup_cmd_response_logger('pin_assign', response)
+    end
+
+    # pinorder=
+    #   This method is used to setup the pin order on the debugger device.
+    #   The pin order will indicate the order that pin data appears in vector
+    #   data.
+    #
+    #   This is a duplicate of pattern_pin_order and can be handled behind the
+    #   scenes in the future.
+    #
+    #   example:
+    #     tester.pinorder = 'tclk,tms,tdi,tdo'
+    def pinorder=(pinorder)
+      @pinorder = pinorder.gsub(/\s+/, '')
+      response = send_cmd('pin_patternorder', @pinorder)
+      setup_cmd_response_logger('pin_patternorder', response)
+    end
+
+    # pinformat=
+    #   This method is used to setup the pin clock format on the debugger device.
+    #   The supported formats are rl and rh
+    #
+    #   example:
+    #     tester.pinformat = 'func_25mhz,tclk,rl'
+    def pinformat=(pinformat)
+      @pinformat = replace_tset_name_w_number(pinformat.gsub(/\s+/, ''))
+      response = send_cmd('pin_format', @pinformat)
+      setup_cmd_response_logger('pin_format', response)
+    end
+
+    # pintiming=
+    #   This method is used to setup the pin timing on the debugger device.
+    #   Timing is relative to the rise and fall of a clock
+    #
+    #   timing value:         0   1   2
+    #   clock waveform:      ___/***\___
+    #
+    #   example:
+    #     tester.pintiming = 'func_25mhz,tms,0,tdi,0,tdo,1'
+    def pintiming=(pintiming)
+      @pintiming = replace_tset_name_w_number(pintiming.gsub(/\s+/, ''))
+      response = send_cmd('pin_timing', @pintiming)
+      setup_cmd_response_logger('pin_timing', response)
+    end
+
+    # replace_tset_name_w_number(csl)
+    #  This method is used by pinformat= and pintiming=
+    #  This method receives a comma separated list of arguments
+    #  the first of which is a timeset name.  A comma
+    #  separated list is returned with the timeset name replaced
+    #  by it's lookup number.  If it is a new timset, a lookup
+    #  number is associated with the name.
+    def replace_tset_name_w_number(csl)
+      args = csl.split(',')
+      args[0] = get_tset_number(args[0])
+      args.join(',')
+    end
+
+    # get_tset_number(name)
+    #   This method returns the test number associated with the
+    #   passed in tset name.  If the name is unknown a new lookup
+    #   number is returned.
+    def get_tset_number(name)
+      unless @tsets_programmed.key?(name)
+        @tsets_programmed[name] = @tset_count
+        @tset_count += 1
+      end
+      @tsets_programmed[name]
+    end
+  end
+end

data/lib/origen_link.rb

@@ -0,0 +1,18 @@
+require 'origen'
+require 'origen_testers'
+require 'socket'
+
+module OrigenLink
+  # Load all files in the lib directory via a wildcard, if your project becomes
+  # large or load order dependencies start to creep in then you may need to
+  # start taking control of this manually as described above.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required up front
+  # you can do that one manually and the let the wildcard take care of the rest.
+  #  Dir.glob("#{File.dirname(__FILE__)}/**/*.rb").sort.each do |file|
+  #    require file
+  #  end
+  Dir.glob("#{File.dirname(__FILE__)}/origen_link/*.rb").sort.each do |file|
+    require file
+  end
+end

data/lib/origen_link_server/LinkSequencer.rb

@@ -0,0 +1,333 @@
+# rubocop:disable Style/FileName: Use snake_case for source file names
+require_relative 'pin_interface'
+
+##################################################
+# OrigenLinkSequencer Class
+#    Instance variables:
+#      pinmap: hash with ["pin name"] = pin object
+#      patternpinindex: hash with ["pin name"] =
+#        integer index into vector data
+#      patternpinorder: Array with pin names in
+#        the vector order
+#
+#    This class processes messages targeted for
+#    pin sequencer interface (vector pattern
+#    execution).
+#
+#    Supported messages:
+#      pin_assign (create pin mapping)
+#        ex: "pin_assign:tck,3,extal,23,tdo,5"
+#
+#      pin_patternorder (define vector pin order)
+#        ex: "pin_patternorder:tdo,extal,tck"
+#
+#      pin_cycle (execute vector data)
+#        ex: "pin_cycle:H11"
+#
+#      pin_clear (clear all setup information)
+#        ex: "pin_clear:"
+#
+#      pin_format (setup a pin with return format)
+#        first argument is the timeset
+#        ex: "pin_format:1,tck,rl"
+#
+#      pin_timing (define when pin events happen)
+#        timing is stored in a timeset hash
+#        first argument is the timeset key
+#        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
+##################################################
+class OrigenLinkSequencer
+  attr_reader :pinmap
+  attr_reader :patternorder
+  attr_reader :cycletiming
+  attr_reader :patternpinindex
+
+  ##################################################
+  # initialize method
+  #    Create empty pinmap, pattern pin index
+  #    and pattern order instance variables
+  ##################################################
+  def initialize
+    @pinmap = Hash.new(-1)
+    @patternpinindex = Hash.new(-1)
+    @patternorder = []
+    @cycletiming = Hash.new(-1)
+  end
+
+  ##################################################
+  # processmessage method
+  #    arguments: message
+  #      message format is <group>_<command>:<args>
+  #    returns: message response
+  #
+  #    This method splits a message into it's
+  #    command and arguments and passes this
+  #    information to the method that performs
+  #    the requested command
+  ##################################################
+  def processmessage(message)
+    command = message.split(':')
+
+    case command[0]
+    when 'pin_assign'
+      pin_assign(command[1])
+    when 'pin_patternorder'
+      pin_patternorder(command[1])
+    when 'pin_cycle'
+      pin_cycle(command[1])
+    when 'pin_clear'
+      pin_clear
+    when 'pin_format'
+      pin_format(command[1])
+    when 'pin_timing'
+      pin_timing(command[1])
+    else
+      'Error Invalid command: ' + command[0].to_s
+    end
+  end
+
+  ##################################################
+  # pin_assign method
+  #    arguments: <args> from the message request
+  #      see "processmessage" method
+  #    returns: "P:" or error message
+  #
+  #    This method creates a pin instance for each
+  #    pin in the pin map and builds the pinmap
+  #    hash.  Before the pinmap is created, any
+  #    information from a previous pattern run is
+  #    cleared.
+  ##################################################
+  def pin_assign(args)
+    pin_clear
+    success = true
+    fail_message = ''
+    argarr = args.split(',')
+    0.step(argarr.length - 2, 2) do |index|
+      @pinmap[argarr[index]] = OrigenLinkPin.new(argarr[index + 1])
+      unless @pinmap[argarr[index]].gpio_valid
+        success = false
+        fail_message = fail_message + 'pin ' + argarr[index] + ' gpio' + argarr[index + 1] + ' is invalid'
+      end
+    end
+    if success
+      'P:'
+    else
+      'F:' + fail_message
+    end
+  end
+
+  ##################################################
+  # new_timeset(tset)
+  #   creates a new empty timeset hash
+  ##################################################
+  def new_timeset(tset)
+    @cycletiming[tset] = {}
+    @cycletiming[tset]['timing'] = [[], [], []]
+  end
+
+  ##################################################
+  # pin_format method
+  #   arguments: <args> from the message request
+  #     Should be <timeset>,<pin>,rl or rh
+  #     multi-clock not currently supported
+  #
+  ##################################################
+  def pin_format(args)
+    argarr = args.split(',')
+    tset_key = argarr.delete_at(0).to_i
+    new_timeset(tset_key) unless @cycletiming.key?(tset_key)
+    @cycletiming[tset_key].delete('rl')
+    @cycletiming[tset_key].delete('rh')
+    0.step(argarr.length - 2, 2) do |index|
+      @cycletiming[tset_key][argarr[index + 1]] = [] unless @cycletiming[tset_key].key?(argarr[index + 1])
+      @cycletiming[tset_key][argarr[index + 1]] << argarr[index]
+    end
+    'P:'
+  end
+
+  ##################################################
+  # pin_timing method
+  #   arguments: <args> from the message request
+  #     Should be '1,pin,-1,pin2,0,pin3,1'
+  #     First integer is timeset number
+  #     If argument is '', default timing is created
+  #     Default timeset number is 0, this is used
+  #     if no timeset is explicitly defined
+  #
+  #     cycle arg:  0   1   2
+  #     waveform : ___/***\___
+  #
+  #   returns "P:" or error message
+  #
+  #   This method sets up a time set.  All retrun
+  #   format pins are driven between 0 and 1 and
+  #   return between 1 and 2.  Non-return pins are
+  #   acted upon during the 0, 1 or 2 time period.
+  ##################################################
+  def pin_timing(args)
+    argarr = args.split(',')
+    tset_key = argarr.delete_at(0).to_i
+    new_timeset(tset_key) unless @cycletiming.key?(tset_key)
+    @cycletiming[tset_key]['timing'].each do |index|
+      index.delete_if { true }
+    end
+    0.step(argarr.length - 2, 2) do |index|
+      @cycletiming[tset_key]['timing'][argarr[index + 1].to_i] << argarr[index]
+    end
+    'P:'
+  end
+
+  ##################################################
+  # pin_patternorder method
+  #    arguments: <args> from the message request
+  #    returns: "P:" or error message
+  #
+  #    This method is used to define the order
+  #    for pin vector data.
+  ##################################################
+  def pin_patternorder(args)
+    argarr = args.split(',')
+    index = 0
+    if @cycletiming.key?(0)
+      @cycletiming[0]['timing'][0].delete_if { true }
+    else
+      new_timeset(0)
+    end
+    argarr.each do |pin|
+      @patternorder << pin
+      @patternpinindex[pin] = index
+      @cycletiming[0]['timing'][0] << pin
+      index += 1
+    end
+    'P:'
+  end
+
+  ##################################################
+  # pin_cycle method
+  #    arguments: <args> from the message request
+  #    returns: "P:" or "F:" followed by results
+  #
+  #    This method executes one cycle of pin vector
+  #    data.  The vector data is decomposed and
+  #    sequenced.  Each pin object and pin data
+  #    is passed to the "process_pindata" method
+  #    for decoding and execution
+  ##################################################
+  def pin_cycle(args)
+    # set default repeats and timeset
+    repeat_count = 1
+    tset = 0
+    if args =~ /,/
+      parsedargs = args.split(',')
+      args = parsedargs.pop
+      parsedargs.each do |arg|
+        if arg =~ /repeat/
+          repeat_count = arg.sub(/repeat/, '').to_i
+        elsif arg =~ /tset/
+          tset = arg.sub(/tset/, '').to_i
+        end
+      end
+    end
+
+    message = ''
+    pindata = args.split('')
+    @cycle_failure = false
+    0.upto(repeat_count - 1) do |count|
+      response = {}
+      # process time 0 events
+      response = process_events(@cycletiming[tset]['timing'][0], pindata)
+      # send drive data for return format pins
+      response = (process_events(@cycletiming[tset]['rl'], pindata)).merge(response)
+      response = (process_events(@cycletiming[tset]['rh'], pindata)).merge(response)
+      # process time 1 events
+      response = process_events(@cycletiming[tset]['timing'][1], pindata).merge(response)
+      # send return data
+      unless @cycletiming[tset]['rl'].nil?
+        @cycletiming[tset]['rl'].each do |pin|
+          process_pindata(@pinmap[pin], '0')
+        end
+      end
+      unless @cycletiming[tset]['rh'].nil?
+        @cycletiming[tset]['rh'].each do |pin|
+          process_pindata(@pinmap[pin], '1')
+        end
+      end
+      # process time 2 events
+      response = process_events(@cycletiming[tset]['timing'][2], pindata).merge(response)
+      if (count == 0) || (@cycle_failure)
+        message = ''
+        @patternorder.each do |pin|
+          message += response[pin]
+        end
+      end
+    end # end cycle through repeats
+    if @cycle_failure
+      rtnmsg = 'F:' + message + '    Expected:' + args
+    else
+      rtnmsg = 'P:' + message
+    end
+    rtnmsg += '    Repeat ' + repeat_count.to_s if repeat_count > 1
+    rtnmsg
+  end
+
+  ##################################################
+  # process_events
+  #   used by pin_cycle to avoid duplicating code
+  ##################################################
+  def process_events(events, pindata)
+    response = {}
+    unless events.nil?
+      events.each do |pin|
+        response[pin] = process_pindata(@pinmap[pin], pindata[@patternpinindex[pin]])
+      end
+    end
+    response
+  end
+
+  ##################################################
+  # process_pindata method
+  #    arguments:
+  #      pin: the pin object to be operated on
+  #      data: the pin data to be executed
+  #    returns: the drive data or read data
+  #
+  #    This method translates pin data into one
+  #    of three possible events.  Drive 0, drive 1
+  #    or read.  Supported character decode:
+  #      drive 0: '0'
+  #      drive 1: '1'
+  #      read: anything else
+  ##################################################
+  def process_pindata(pin, data)
+    if data == '0' || data == '1'
+      pin.out(data)
+      data
+    else
+      case pin.in
+      when '0'
+        @cycle_failure = true if data == 'H'
+        'L'
+      when '1'
+        @cycle_failure = true if data == 'L'
+        'H'
+      else
+        'W'
+      end
+    end
+  end
+
+  ##################################################
+  # pin_clear method
+  #
+  #    This method clears all storage objects.  It
+  #    is called by the "pin_assign" method
+  ##################################################
+  def pin_clear
+    @pinmap.clear
+    @patternpinindex.clear
+    @patternorder.delete_if { true }
+    @cycletiming.clear
+    'P:'
+  end
+end

data/lib/origen_link_server/LinkTCPServer.rb

@@ -0,0 +1,45 @@
+# rubocop:disable Style/FileName: Use snake_case for source file names.
+require 'socket'
+require_relative 'LinkSequencer'
+
+server = TCPServer.open('192.168.0.2', 12_777)
+puts 'server started'
+pinsequencer = OrigenLinkSequencer.new
+
+# time measurements for debug only
+# total_receive_time=0
+# total_process_time=0
+# total_xmit_time=0
+# total_close_time=0
+# total_packets=0
+loop do
+  client = server.accept
+  # time measurements for debug only
+  # t1 = Time.now
+  message = client.gets
+  # t2 = Time.now
+  # process the message
+  # for now only pin_ messages are accepted
+  response = pinsequencer.processmessage(message.chomp)
+  # t3 = Time.now
+  client.puts(response)
+  # t4 = Time.now
+  client.close
+  # t5 = Time.now
+
+  # puts "packet process time: #{t3-t2}"
+  # total_receive_time += (t2-t1)
+  # total_process_time += (t3-t2)
+  # total_xmit_time += (t4-t3)
+  # total_close_time += (t5-t4)
+  # total_packets += 1
+  # puts "total receive time: #{total_receive_time}"
+  # puts "total process time: #{total_process_time}"
+  # puts "total xmit time: #{total_xmit_time}"
+  # puts "total close time: #{total_close_time}"
+  # puts ''
+  # puts "total receive time: #{total_receive_time/total_packets}"
+  # puts "total process time: #{total_process_time/total_packets}"
+  # puts "total xmit time: #{total_xmit_time/total_packets}"
+  # puts "total close time: #{total_close_time/total_packets}"
+end