origen_link 0.1.0.pre0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e1bcf6176e63bcb31f823ec75e8171d5f41f678
-  data.tar.gz: b8773221ecda2487be4b458341b07260f3298a38
+  metadata.gz: faee2177091aa943a5592a6bdf44edc8813eb3b8
+  data.tar.gz: f50c5b16dc546bd39c7fb45bacb11bd9340053f1
 SHA512:
-  metadata.gz: e5f8bb591f2113d737a4e2ec9adcb035aab944e61558e7927004ef3ed6327c4438f9a0619c1ab181a41d124505aa1e6fe0e47238af876a26d1c4b88740b0f19f
-  data.tar.gz: 5a345ff111d0fe9779bff83d317878addc8baec9551c546c471dcda03f65534d9360679e56b5d6519b66d22560975349921bc9e4bfc6b3a96f423c256e8acd3e
+  metadata.gz: b16813b53e7e2a87008c86055991cc18e4b113502e02437ca04ba1283d5950ffb9c41c618fb0d0e69990030ba6b82addfaa9ca552747c2607b2fab1398665af9
+  data.tar.gz: 71a143e7bf8008e829af1adf9cb5c6bfe7da1ec5748e824221fbf29648bcb698c19139b6a96d71064db9e81fb5938ff117f64912d6cc371128b9b5661eb9fbe3

data/bin/start_link_server

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+require 'socket'
+require 'origen_link/server/sequencer'
+
+server = TCPServer.open('', 12_777)
+puts 'server started'
+pinsequencer = OrigenLink::Server::Sequencer.new
+
+loop do
+  client = server.accept
+  response = ''
+  while (message = client.gets) != "\n"
+    # process the message
+    # for now only pin_ messages are accepted
+    response = response + pinsequencer.processmessage(message.chomp) + "\n"
+  end
+  client.write(response)
+  client.close
+end

data/config/boot.rb

@@ -3,5 +3,6 @@
 # application requires
 require "origen_link"
 
-require "origen_link/test/test_dut"
-require "origen_link/test/test_dut_controller"
+require "origen_link/test/top_level"
+require "origen_link/test/top_level_controller"
+require "origen_link/test/vector_based"

data/config/version.rb

@@ -2,7 +2,7 @@ module OrigenLink
   MAJOR = 0
   MINOR = 1
   BUGFIX = 0
-  DEV = 0
+  DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/origen_link.rb

@@ -1,18 +1,4 @@
 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
+require 'origen_link/vector_based'

data/lib/origen_link/callback_handlers.rb

@@ -0,0 +1,13 @@
+module OrigenLink
+  class CallbackHandlers
+    include Origen::Callbacks
+
+    def pattern_generated(output_file)
+      tester.finalize_pattern(output_file)
+    end
+
+    def before_pattern(pattern_name)
+      tester.initialize_pattern
+    end
+  end
+end

data/lib/origen_link/server/jtag.rb

@@ -0,0 +1,180 @@
+require 'origen_link/server/pin'
+
+module OrigenLink
+  module Server
+    class Jtag
+      attr_reader :tdoval
+      attr_accessor :verbose_enable
+      attr_accessor :anytdofail
+
+      def initialize(tdiio = 16, tdoio = 23, tmsio = 19, tckio = 26, tck_period = 0.000001)
+        @tdipin = Pin.new(tdiio, :out)
+        @tdopin = Pin.new(tdoio, :in)
+        @tmspin = Pin.new(tmsio, :out)
+        @tckpin = Pin.new(tckio, :out)
+        @tck_half_period = tck_period / 2
+        @tdoval = 0
+        @tdostr = ''
+        @verbose_enable = true
+        @anytdofail = false
+      end
+
+      def tck_period=(value)
+        @tck_half_period = value / 2
+      end
+
+      def destroy
+        @tdipin.destroy
+        @tdopin.destroy
+        @tmspin.destroy
+        @tckpin.destroy
+        @tdipin = nil
+        @tdopin = nil
+        @tmspin = nil
+        @tckpin = nil
+      end
+
+      def do_cycle(tdival, tmsval, capturetdo = false)
+        @tdipin.out(tdival)
+        @tmspin.out(tmsval)
+        sleep @tck_half_period
+        @tckpin.out(1)
+        sleep @tck_half_period
+
+        if capturetdo
+          @tdostr = @tdopin.in + @tdostr
+        end
+        @tckpin.out(0)
+      end
+
+      def do_tlr
+        8.times { do_cycle(0, 1) }
+        do_cycle(0, 0)
+      end
+
+      def do_shift(numbits, value, capturetdo = false, suppresscomments = false, tdocompare = '')
+        @tdoval = 0
+        @tdostr = ''
+        (numbits - 1).times do |bit|
+          do_cycle(value[bit], 0, capturetdo)
+        end
+        do_cycle(value[numbits - 1], 1, capturetdo)
+
+        @tdoval = @tdostr.to_i(2) if capturetdo
+
+        if !(suppresscomments) && @verbose_enable && capturetdo
+          puts 'TDO output = 0x' + @tdoval.to_s(16)
+        end
+
+        if capturetdo && tdocompare != ''
+          thiscomparefail = false
+          numbits.times do |bit|
+            if tdocompare[numbits - 1 - bit] == 'H'
+              compareval = 1
+            elsif tdocompare[numbits - 1 - bit] == 'L'
+              compareval = 0
+            else
+              compareval = @tdoval[bit]
+            end
+
+            if @tdoval[bit] != compareval
+              @anytdofail = true
+              thiscomparefail = true
+            end
+          end
+
+          tdovalstr = @tdoval.to_s(2)
+          tdovalstr = '0' * (numbits - tdovalstr.length) + tdovalstr
+
+          if thiscomparefail
+            puts '****************************>>>>>>>>>>>>>>>>> TDO failure <<<<<<<<<<<<<<<<<<****************************'
+            puts 'expected: ' + tdocompare
+            puts 'received: ' + tdovalstr
+          else
+            puts 'TDO compare pass'
+            puts 'expected: ' + tdocompare
+            puts 'received: ' + tdovalstr
+          end
+        end
+      end
+
+      def do_ir(numbits, value, options = {})
+        defaults = {
+          capturetdo:	      false,
+          suppresscomments:	false,
+          tdocompare:	      ''
+        }
+        options = defaults.merge(options)
+
+        if !(options[:suppresscomments]) && @verbose_enable
+          puts "	shift IR, #{numbits} bits, value = 0x" + value.to_s(16)
+        end
+
+        if options[:tdocompare] != ''
+          capturetdo = true
+        else
+          capturetdo = options[:capturetdo]
+        end
+
+        # Assume starting from run test idle
+        # Advance to shift IR
+        do_cycle(0, 1)
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+        do_cycle(0, 0)
+
+        do_shift(numbits, value, capturetdo, options[:suppresscomments], options[:tdocompare])
+
+        # Return to run test idle
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+      end
+
+      def do_dr(numbits, value, options = {})
+        defaults = {
+          capturetdo:	      true,
+          suppresscomments:	false,
+          tdocompare:	      ''
+        }
+        options = defaults.merge(options)
+        if !(options[:suppresscomments]) && @verbose_enable
+          puts "	shift DR, #{numbits} bits, value = 0x" + value.to_s(16)
+        end
+
+        if options[:tdocompare] != ''
+          capturetdo = true
+        else
+          capturetdo = options[:tdocompare]
+        end
+
+        # Assume starting from run test idle
+        # Advance to shift DR
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+        do_cycle(0, 0)
+
+        do_shift(numbits, value, capturetdo, options[:suppresscomments], options[:tdocompare])
+
+        # Return to run test idle
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+      end
+
+      def pause_dr
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+        do_cycle(0, 0)
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+        do_cycle(0, 1)
+        do_cycle(0, 1)
+        do_cycle(0, 0)
+      end
+
+      def pause_ir
+        do_cycle(0, 1)
+        pause_dr
+      end
+    end
+  end
+end

data/lib/origen_link/server/pin.rb

@@ -0,0 +1,125 @@
+# OrigenLink::Server::Pin class manipulate input/output pins of the Udoo
+# using exported file objects.  If the pin is not exported, it
+# will be exported when a pin is initialized
+#
+# initialize:
+#  description - This method will execute system command
+#                "sudo echo ionumber > /sys/class/gpio/export"
+#                to create the IO file interface.  It will
+#                set the direction, initial pin state and initialize
+#                instance variables
+#  ionumber - required, value indicating the pin number (BCM IO number,
+#             not the header pin number)
+#  direction - optional, specifies the pin direction.  A pin is
+#              initialized as an input if a direction isn't specified.
+#
+#
+#  out:
+#    description - Sets the output state of the pin.  If the pin
+#                  is setup as an input, the direction will first
+#                  be changed to output.
+#
+#
+#  in:
+#    description - Reads and returns state of the pin.  If the pin
+#                  is setup as an output, the direction will first
+#                  be changed to input.
+#
+#
+#  update_direction:
+#    description - Sets the pin direction
+#
+#  direction - specifies the pin direction.  A pin is
+#              initialized as an input if a direction isn't specified.
+#
+#  Valid direction values:
+#    :in	-	input
+#    :out	-	output
+#    :out_high	-	output, initialized high
+#    :out_low	-	output, initialized low
+module OrigenLink
+  module Server
+    class Pin
+      @@pin_setup = {
+        in:  'in',
+        out: 'out'
+      }
+
+      attr_reader :gpio_valid
+
+      def initialize(ionumber, direction = :in)
+        @ionumber = Integer(ionumber)
+        @pin_dir_name = "#{Server.gpio_dir}/gpio#{@ionumber}/direction"
+        @pin_val_name = "#{Server.gpio_dir}/gpio#{@ionumber}/value"
+        if !File.exist?(@pin_dir_name)
+          system("echo #{@ionumber} > #{Server.gpio_dir}/export")
+          sleep 0.05
+          if $CHILD_STATUS == 0
+            @gpio_valid = true
+          else
+            @gpio_valid = false
+          end
+        else
+          @gpio_valid = true
+        end
+        if @gpio_valid
+          if File.writable?(@pin_dir_name)
+            @pin_dir_obj = File.open(@pin_dir_name, 'w')
+            update_direction(direction)
+          else
+            @gpio_valid = false
+            puts "#{@pin_dir_name} is not writable. Fix permissions or run as super user."
+          end
+          @pin_val_obj = File.open(@pin_val_name, 'r+') if @gpio_valid
+        end
+      end
+
+      def destroy
+        if @gpio_valid
+          @pin_dir_obj.close
+          @pin_val_obj.close
+          # system("echo #{@ionumber} > /sys/class/gpio/unexport")
+          # puts "pin #{@ionumber} is no longer exported"
+        end
+      end
+
+      def out(value)
+        if @gpio_valid
+          if @direction == :in
+            update_direction(:out)
+          end
+          @pin_val_obj.write(value)
+          @pin_val_obj.flush
+        end
+      end
+
+      def in
+        if @gpio_valid
+          if @direction == :out
+            update_direction(:in)
+          end
+          # below is original read - slow to reopen every time
+          # File.open(@pin_val_name, 'r') do |file|
+          #  file.read#.chomp
+          # end
+          # end original read
+          @pin_val_obj.pos = 0
+          @pin_val_obj.getc
+        end
+      end
+
+      def update_direction(direction)
+        if @gpio_valid
+          @pin_dir_obj.pos = 0
+          @pin_dir_obj.write(@@pin_setup[direction])
+          @pin_dir_obj.flush
+          @direction = direction
+        end
+      end
+
+      def to_s
+        'OrigenLinkPin' + @ionumber.to_s
+      end
+    end
+  end
+end

data/lib/origen_link/server/sequencer.rb

@@ -0,0 +1,353 @@
+require 'origen_link/server/pin'
+
+##################################################
+# OrigenLink::Server::Sequencer 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
+##################################################
+module OrigenLink
+  module Server
+    def self.gpio_dir=(path)
+      @gpio_dir = path
+    end
+
+    def self.gpio_dir
+      @gpio_dir || '/sys/class/gpio'
+    end
+
+    class Sequencer
+      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]] = Pin.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'
+            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
+      #
+      #    This method clears all storage objects.  It
+      #    is called by the "pin_assign" method
+      ##################################################
+      def pin_clear
+        @pinmap.each { |pin_name, pin| pin.destroy }
+        @pinmap.clear
+        @patternpinindex.clear
+        @patternorder.delete_if { true }
+        @cycletiming.clear
+        'P:'
+      end
+    end
+  end
+end