origen_link 0.2.0 → 0.3.0

data/lib/origen_link/server/sequencer.rb

@@ -34,6 +34,11 @@ require 'origen_link/server/pin'
 #        timing is stored in a timeset hash
 #        first argument is the timeset key
 #        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
+#
+#      version (check version of app server is
+#        running)
+#        ex: "version:"
+#        response ex: "P:0.2.0.pre0"
 ##################################################
 module OrigenLink
   module Server
@@ -45,10 +50,50 @@ module OrigenLink
       @gpio_dir || '/sys/class/gpio'
     end
 
+    ##################################################
+    # OrigenLink::Server::Sequencer Class
+    #
+    #    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
+    #
+    #      version (check version of app server is
+    #        running)
+    #        ex: "version:"
+    #        response ex: "P:0.2.0.pre0"
+    ##################################################
     class Sequencer
+      # code version of the server (populated by start_link_server)
+      attr_accessor :version
+      # hash holding the pinmap ('name' => pin object)
       attr_reader :pinmap
+      # array of pin names in pattern order
       attr_reader :patternorder
+      # hash holding programmed time set information
       attr_reader :cycletiming
+      # hash holding pin pattern order ('name' => index)
       attr_reader :patternpinindex
 
       ##################################################
@@ -61,6 +106,7 @@ module OrigenLink
         @patternpinindex = Hash.new(-1)
         @patternorder = []
         @cycletiming = Hash.new(-1)
+        @version = ''
       end
 
       ##################################################
@@ -90,6 +136,10 @@ module OrigenLink
           pin_format(command[1])
         when 'pin_timing'
           pin_timing(command[1])
+        when 'pin_timingv2'
+          pin_timingv2(command[1])
+        when 'version'
+          "P:#{@version}"
         else
           'Error Invalid command: ' + command[0].to_s
         end
@@ -126,13 +176,89 @@ module OrigenLink
         end
       end
 
+      ########################################################
+      # pin_timingv2 method
+      #   arguments: <args> from the message request
+      #     Should be '1,drive,5,pin,10,pin2,|compare,0,pin3'
+      #     First integer is timeset number
+      #
+      #   returns "P:" or error message
+      #
+      #   This method sets up a time set.  Any arbitrary
+      #   waveform can be generated
+      #
+      ########################################################
+      def pin_timingv2(args)
+        # get the tset number
+        argarr = args.split(',')
+        tset_key = argarr.delete_at(0).to_i
+        new_timeset(tset_key)
+        args = argarr.join(',')
+
+        invalid_pins = []
+
+        # process and load the timeset
+        waves = args.split('|')
+        waves.each do |w|
+          argarr = w.split(',')
+          wave_type = argarr.delete_at(0)
+          event_data_key = wave_type + '_event_data'
+          event_pins_key = wave_type + '_event_pins'
+          w = argarr.join(',')
+          events = w.split(';')
+          events.each do |e|
+            argarr = e.split(',')
+            event_key = argarr.delete_at(0).to_f
+            @cycletiming[tset_key]['events'] << event_key
+            @cycletiming[tset_key][event_data_key][event_key] = [] unless @cycletiming[tset_key][event_data_key].key?(event_key)
+            @cycletiming[tset_key][event_data_key][event_key] << argarr.delete_at(0)
+            # now load the pins for this event
+            @cycletiming[tset_key][event_pins_key][event_key] = [] unless @cycletiming[tset_key][event_pins_key].key?(event_key)
+            @cycletiming[tset_key][event_pins_key][event_key] << []
+            argarr.each do |pin|
+              if @pinmap.key?(pin)
+                @cycletiming[tset_key][event_pins_key][event_key].last << @pinmap[pin]
+              else
+                invalid_pins << pin
+              end
+            end # of argarr.each
+          end # of events.each
+        end # of waves.each
+        @cycletiming[tset_key]['events'].uniq!
+        @cycletiming[tset_key]['events'].sort!
+
+        # return result
+        if invalid_pins.size > 0
+          'F:Invalid pins (not in pinmap): ' + invalid_pins.join(', ')
+        else
+          'P:'
+        end
+      end # of def pin_timingv2
+
       ##################################################
       # new_timeset(tset)
       #   creates a new empty timeset hash
+      #
+      #   timing format:
+      #     ['events'] = [0, 5, 10, 35]
+      #     ['drive_event_data'] = {
+      #           0: ['data']
+      #          10: ['data','0']
+      #          35: ['0']
+      #         }
+      #     ['drive_event_pins'] = {
+      #           0: [[pin_obj1, pin_obj2]]
+      #          10: [[pin1,pin2], [pin3]]
+      #           etc.
+      #         }
       ##################################################
       def new_timeset(tset)
         @cycletiming[tset] = {}
-        @cycletiming[tset]['timing'] = [[], [], []]
+        @cycletiming[tset]['events'] = []
+        @cycletiming[tset]['drive_event_data'] = {}
+        @cycletiming[tset]['drive_event_pins'] = {}
+        @cycletiming[tset]['compare_event_data'] = {}
+        @cycletiming[tset]['compare_event_pins'] = {}
       end
 
       ##################################################
@@ -146,11 +272,24 @@ module OrigenLink
         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')
+        @cycletiming[tset_key]['events'] += [1, 3]
+        @cycletiming[tset_key]['events'].sort!
+        [1, 3].each do |event|
+          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
+        end
+        @cycletiming[tset_key]['compare_event_data'][1] = ['data']
         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]
+          drive_type = argarr[index + 1]
+          pin_name = argarr[index]
+          @cycletiming[tset_key]['drive_event_data'][1] = ['data']
+          @cycletiming[tset_key]['drive_event_pins'][1][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['drive_event_pins'][3][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['compare_event_pins'][1] = [[@pinmap[pin_name]]]
+          if drive_type == 'rl'
+            @cycletiming[tset_key]['drive_event_data'][3] = ['0']
+          else
+            @cycletiming[tset_key]['drive_event_data'][3] = ['1']
+          end
         end
         'P:'
       end
@@ -173,16 +312,41 @@ module OrigenLink
       #   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 }
+        [0, 2, 4].each do |event|
+          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
+          @cycletiming[tset_key]['compare_event_pins'][event] = [[]]
         end
+
+        # process the information received
         0.step(argarr.length - 2, 2) do |index|
-          @cycletiming[tset_key]['timing'][argarr[index + 1].to_i] << argarr[index]
+          event = argarr[index + 1].to_i
+          # reorder event number to allow rising/falling edges
+          event *= 2
+          pin_name = argarr[index]
+          @cycletiming[tset_key]['events'] << event
+          @cycletiming[tset_key]['drive_event_data'][event] = ['data']
+          @cycletiming[tset_key]['drive_event_pins'][event][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['compare_event_data'][event] = ['data']
+          @cycletiming[tset_key]['compare_event_pins'][event][0] << @pinmap[pin_name]
+        end
+
+        # remove events with no associated pins
+        @cycletiming[tset_key]['events'].uniq!
+        @cycletiming[tset_key]['events'].sort!
+        [0, 2, 4].each do |event|
+          if @cycletiming[tset_key]['drive_event_pins'][event][0].size == 0
+            @cycletiming[tset_key]['events'] -= [event]
+            @cycletiming[tset_key]['drive_event_data'].delete(event)
+            @cycletiming[tset_key]['drive_event_pins'].delete(event)
+            @cycletiming[tset_key]['compare_event_data'].delete(event)
+            @cycletiming[tset_key]['compare_event_pins'].delete(event)
+          end
         end
         'P:'
       end
@@ -198,15 +362,18 @@ module OrigenLink
       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
+        new_timeset(0)
         argarr.each do |pin|
           @patternorder << pin
-          @patternpinindex[pin] = index
-          @cycletiming[0]['timing'][0] << pin
+          @pinmap[pin].pattern_index = index	# pattern index stored in pin object now
+          @patternpinindex[pin] = index		# to be removed
+
+          # define default timing
+          @cycletiming[0]['events'] << index
+          @cycletiming[0]['drive_event_data'][index] = ['data']
+          @cycletiming[0]['drive_event_pins'][index] = [[@pinmap[pin]]]
+          @cycletiming[0]['compare_event_data'][index] = ['data']
+          @cycletiming[0]['compare_event_pins'][index] = [[@pinmap[pin]]]
           index += 1
         end
         'P:'
@@ -222,6 +389,7 @@ module OrigenLink
       #    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
@@ -240,108 +408,48 @@ module OrigenLink
         end
 
         message = ''
-        pindata = args.split('')
-        @cycle_failure = false
+        # load pattern cycle data into pin objects
+        @pinmap.each_value { |p| p.load_pattern_data(args) }
+        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')
+          # process timing events
+          @cycletiming[tset]['events'].each do |event|
+            # process drive events
+            if @cycletiming[tset]['drive_event_pins'].key?(event)
+              @cycletiming[tset]['drive_event_pins'][event].each_index do |i|
+                @cycletiming[tset]['drive_event_pins'][event][i].each do |p|
+                  p.process_event(:drive, @cycletiming[tset]['drive_event_data'][event][i])
+                end
+              end
             end
-          end
-          unless @cycletiming[tset]['rh'].nil?
-            @cycletiming[tset]['rh'].each do |pin|
-              process_pindata(@pinmap[pin], '1')
+
+            # process compare events
+            if @cycletiming[tset]['compare_event_pins'].key?(event)
+              @cycletiming[tset]['compare_event_pins'][event].each_index do |i|
+                @cycletiming[tset]['compare_event_pins'][event][i].each do |p|
+                  p.process_event(:compare, @cycletiming[tset]['compare_event_data'][event][i])
+                end
+              end
             end
+          end # event
+
+          # build response message
+          message += ' ' unless count == 0
+
+          @patternorder.each do |p|
+            message += @pinmap[p].response
+            cycle_failure = true if @pinmap[p].cycle_failure
           end
-          # process time 2 events
-          response = process_events(@cycletiming[tset]['timing'][2], pindata).merge(response)
-          # changing response format to return all data for easier debug, below is original method
-          # TODO: remove the commented code once return format and delay handling is finalized
-          # if (count == 0) || (@cycle_failure)
-          #  message = ''
-          #  @patternorder.each do |pin|
-          #    message += response[pin]
-          #  end
-          # end
-          message = message + ' ' unless count == 0
-          @patternorder.each do |pin|
-            message += response[pin]
-          end
-        end # end cycle through repeats
-        if @cycle_failure
+        end # count
+        if cycle_failure
           rtnmsg = 'F:' + message + '    Expected:' + args
         else
           rtnmsg = 'P:' + message
         end
-        # no need to return repeat count since all data is returned
-        # TODO: remove the commented code once return format and delay handling is finalized
-        # 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'
-            if data == 'X'
-              '.'
-            else
-              'L'
-            end
-          when '1'
-            @cycle_failure = true if data == 'L'
-            if data == 'X'
-              '`'
-            else
-              'H'
-            end
-          else
-            'W'
-          end
-        end
-      end
-
       ##################################################
       # pin_clear method
       #

data/lib/origen_link/server_com.rb

@@ -1,5 +1,7 @@
 module OrigenLink
   module ServerCom
+    # send a single command to the server
+    #
     # send_cmd(cmdstr, argstr)
     #   cmdstr is a valid command.  <category>_<command>
     #     Ex: 'pin_assign'
@@ -72,6 +74,7 @@ module OrigenLink
       response    # ensure the response is passed along
     end
 
+    # Send the stored batch of vectors to the server
     def send_batch(vector_batch)
       vector_batch_str = @user_name + "\n" + vector_batch.join("\n") + "\n\n"
       user_status = ''
@@ -124,7 +127,8 @@ module OrigenLink
       response
     end
 
-    # setup_cmd_response_logger
+    # Handle a server response (inform of Failures)
+    #
     #   There are several setup commands that initialize the debugger device with
     #   information about how to interact with the dut.  All of the setup commands
     #   return pass or fail.  This method exists so that the code doesn't have to

data/lib/origen_link/test/top_level.rb

@@ -15,10 +15,10 @@ module OrigenLink
           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 :tclk, meta: { link_io: 119 }
+        add_pin :tdi, meta: { link_io: 116 }
+        add_pin :tdo, meta: { link_io: 124 }
+        add_pin :tms, meta: { link_io: 6 }
         add_pin :resetb
         add_pins :port_a, size: 8
 
@@ -31,7 +31,7 @@ module OrigenLink
           else
             tester.pinmap = 'tclk,119,tms,6,tdi,116,tdo,124' unless options[:missing_pinmap_test]
           end
-          tester.pinorder = 'tclk,tms,tdi,tdo'
+          # tester.pinorder = 'tclk,tms,tdi,tdo'
         end
       end