origen 0.0.1 → 0.0.2

data/lib/origen/sub_blocks.rb

@@ -0,0 +1,298 @@
+module Origen
+  module SubBlocks
+    # This will be called whenever an object that includes this module
+    # is instantiated
+    #
+    # @api private
+    def init_sub_blocks(*args)
+      options = args.find { |a| a.is_a?(Hash) }
+      if options
+        # Using reg_base_address for storage to avoid class with the original Origen base
+        # address API, but will accept any of these
+        @reg_base_address = options.delete(:reg_base_address) || options.delete(:reg_base_address) ||
+                            options.delete(:base_address) || options.delete(:base) || 0
+        @domain_names = [options.delete(:domain) || options.delete(:domains)].flatten.compact
+        @domain_specified = !@domain_names.empty?
+        @path = options.delete(:path)
+        @abs_path = options.delete(:abs_path) || options.delete(:absolute_path)
+      end
+      if is_a?(SubBlock)
+        options.each do |k, v|
+          send("#{k}=", v)
+        end
+      end
+    end
+
+    module Domains
+      def domain(name, options = {})
+        domains[name] = Origen::Registers::Domain.new(name, options)
+      end
+
+      def domain_specified?
+        @domain_specified
+      end
+
+      def domains
+        @domains ||= {}.with_indifferent_access
+        if @domain_names
+          @domain_names.each do |domain|
+            if domain.is_a?(Origen::Registers::Domain)
+              @domains[domain.id] = domain
+            elsif parent.domains[domain]
+              @domains[domain] = parent.domains[domain]
+            else
+              fail "Uknown domain: #{domain}"
+            end
+          end
+          @domain_names = nil
+        end
+        if parent && @domains.empty?
+          parent.domains
+        else
+          @domains
+        end
+      end
+      alias_method :register_domains, :domains
+    end
+    include Domains
+
+    # Jumping through some hoops here since many Origen modules talk about an owner,
+    # but would prefer to start standardizing on parent in future, so this should give
+    # most Origen models a parent method
+    module Parent
+      def parent
+        @owner
+      end
+      alias_method :owner, :parent
+
+      unless method_defined? :owner=
+        def owner=(obj)
+          if obj.respond_to?(:controller) && obj.controller
+            @owner = obj.controller
+          else
+            @owner = obj
+          end
+        end
+      end
+      alias_method :parent=, :owner=
+    end
+    include Parent
+
+    module RegBaseAddress
+      def reg_base_address(options = {})
+        if options[:relative]
+          reg_base_address_for_domain(options)
+        else
+          total_reg_base_address = reg_base_address_for_domain(options)
+          if parent
+            total_reg_base_address += parent.reg_base_address(options)
+          end
+          total_reg_base_address
+        end
+      end
+
+      def reg_base_address_for_domain(options)
+        if @reg_base_address
+          if @reg_base_address.is_a?(Hash)
+            if options[:domain]
+              if options[:domain].is_a?(Hash)
+                domains = options[:domain].keys
+              else
+                domains = [options[:domain]].flatten
+              end
+              bases = domains.map do |d|
+                @reg_base_address.with_indifferent_access[d]
+              end.compact
+              if bases.empty?
+                @reg_base_address[:default] || 0
+              else
+                if bases.size > 1
+                  fail 'Multiple base addresses found, specify the domain you want, e.g. reg.address(domain: :ahb)'
+                else
+                  bases.first
+                end
+              end
+            else
+              @reg_base_address[:default] || 0
+            end
+          else
+            @reg_base_address
+          end
+        else
+          0
+        end
+      end
+
+      unless method_defined? :base_address
+        def base_address
+          reg_base_address
+        end
+      end
+    end
+    include RegBaseAddress
+
+    module Path
+      def path=(val)
+        @path = val
+      end
+
+      def path_var
+        @path
+      end
+
+      def abs_path=(val)
+        @abs_path = val
+      end
+      alias_method :full_path=, :abs_path=
+
+      def abs_path
+        @abs_path
+      end
+      alias_method :full_path, :abs_path
+
+      def path(options = {})
+        return abs_path if abs_path
+        if is_a?(Origen::Registers::BitCollection)
+          # Special case where path relative to the register has been requested
+          if options[:relative_to] == parent
+            if size == 1
+              return "[#{position}]"
+            else
+              return "[#{position + size - 1}:#{position}]"
+            end
+          else
+            p = parent.parent
+          end
+        else
+          p = parent
+        end
+        if p && p != options[:relative_to]
+          if p.path(options).empty?
+            root = ''
+          else
+            root = "#{p.path(options)}."
+          end
+        else
+          root = ''
+        end
+        local = (path_var || name || self.class.to_s.split('::').last).to_s
+        if local == 'hidden'
+          root.chop
+        else
+          "#{root}#{local}"
+        end
+      end
+      alias_method :hdl_path, :path
+    end
+    include Path
+
+    # Returns a hash containing all immediate children of the given sub-block
+    def sub_blocks
+      @sub_blocks ||= {}.with_indifferent_access
+    end
+    alias_method :children, :sub_blocks
+
+    # Delete all sub_blocks by emptyig the Hash
+    def delete_sub_blocks
+      @sub_blocks = {}
+    end
+
+    def sub_blocks_array
+      sub_blocks.map { |_name, sub_block| sub_block }
+    end
+    alias_method :children_array, :sub_blocks_array
+
+    # Returns an array containing all descendant child objects of the given sub-block, i.e. this returns
+    # an array containing children's children as well
+    #
+    # Note that this returns an array instead of a hash since there could be naming collisions in the
+    # hash keys
+    def all_sub_blocks
+      @all_sub_blocks ||= begin
+        (sub_blocks_array + sub_blocks_array.map(&:all_sub_blocks)).flatten
+      end
+    end
+
+    # Returns true if the given sub block owns at least one register
+    def owns_registers?
+      if regs
+        regs.is_a?(Origen::Registers::RegCollection) && !regs.empty?
+      else
+        false
+      end
+    end
+
+    def sub_block(name, options = {})
+      class_name = options.delete(:class_name)
+      if class_name
+        begin
+          klass = eval("::#{namespace}::#{class_name}")
+        rescue
+          begin
+            klass = eval(class_name)
+          rescue
+            begin
+              klass = eval("#{self.class}::#{class_name}")
+            rescue
+              puts "Could not find class: #{class_name}"
+              raise 'Unknown sub block class!'
+            end
+          end
+        end
+      else
+        klass = Origen::SubBlock
+      end
+      unless klass.respond_to?(:includes_origen_model)
+        puts 'Any class which is to be instantiated as a sub_block must include Origen::Model,'
+        puts "add this to #{klass}:"
+        puts ''
+        puts '  include Origen::Model'
+        puts ''
+        fail 'Sub block does not include Origen::Model!'
+      end
+      block = klass.new(options.merge(parent: self))
+      block.name = name
+      sub_blocks[name] = block
+      if respond_to?(name)
+        # puts "Tried to create a sub-block named #{name} in #{self.class}, but it already has a method with this name!"
+        # puts "To avoid confusion rename one of them and try again!"
+        # raise "Non-unique sub-block name!"
+      else
+        define_singleton_method name do
+          sub_blocks[name]
+        end
+      end
+      block
+    end
+
+    def namespace
+      self.class.to_s.sub(/::[^:]*$/, '')
+    end
+  end
+
+  # A simple class that will be instantiated by default when a sub block is
+  # defined without another class name specified
+  #
+  # This class includes support for registers, pins, etc.
+  class SubBlock
+    include Origen::Model
+
+    # Used to create attribute accessors on the fly.
+    #
+    # On first call of a missing method a method is generated to avoid the missing lookup
+    # next time, this should be faster for repeated lookups of the same method, e.g. reg
+    def method_missing(method, *args, &block)
+      return regs(method) if self.has_reg?(method)
+      if method.to_s =~ /=$/
+        define_singleton_method(method) do |val|
+          instance_variable_set("@#{method.to_s.sub('=', '')}", val)
+        end
+      else
+        define_singleton_method(method) do
+          instance_variable_get("@#{method}")
+        end
+      end
+      send(method, *args, &block)
+    end
+  end
+end

data/lib/origen/tester/api.rb

@@ -0,0 +1,277 @@
+module Origen
+  module Tester
+    # This module implements the basic set of methods that a tester must have
+    # in order for Origen to talk to it.
+    #
+    # They can be overridden by tester specific classes and who may go on to add
+    # additional methods of their own.
+    #
+    # Essentially this API means that any class that includes Origen::Tester will
+    # function as a tester, although it might not do very much!
+    module API
+      attr_accessor :includes
+      attr_accessor :comment_level
+      attr_accessor :generating
+      attr_accessor :inhibit_comments
+      attr_accessor :inhibit_vectors
+
+      def name
+        @name || self.class
+      end
+
+      def generate?
+        true
+      end
+
+      def generating_pattern?
+        @generating == :pattern
+      end
+
+      def generating_program?
+        @generating == :program
+      end
+
+      def pat_extension
+        @pat_extension || 'txt'
+      end
+      alias_method :pattern_extension, :pat_extension
+
+      def comment_char
+        @comment_char || '//'
+      end
+
+      def program_comment_char
+        @program_comment_char || comment_char
+      end
+
+      def pattern_header(*_args)
+      end
+
+      def pattern_footer(*_args)
+      end
+
+      def step_comment_prefix
+        @step_comment_prefix || '##'
+      end
+
+      def is_vector_based?
+        return @vector_based if defined?(@vector_based)
+        true
+      end
+
+      def is_command_based?
+        !is_vector_based?
+      end
+
+      def j750?
+        false
+      end
+
+      def v93k?
+        false
+      end
+
+      def ultraflex?
+        false
+      end
+
+      def doc?
+        false
+      end
+
+      def j750_hpt?
+        false
+      end
+
+      def annotate(_msg, _options = {})
+      end
+
+      # Ignore fails on the given pins for the duration of the given block, this
+      # has the effect of temporarily setting the states of the given pins to
+      # don't care.
+      def ignore_fails(*pins)
+        pins.each(&:suspend)
+        yield
+        pins.each(&:resume)
+      end
+
+      # Output a comment in the pattern, normally you would not call this directly
+      # and instead use these shorthand methods:
+      #   cc "Some comment"
+      #   ss "A single line step comment"
+      #   step_comment do
+      #       cc "A multi line"
+      #       cc "step comment"
+      #   end
+      def c1(msg, _options = {})
+        prefix = comment_char + ' '
+        prefix += step_comment_prefix + ' ' if @step_comment_on
+        push_comment(prefix + msg.to_s)
+      end
+
+      def c2(msg, options = {})
+        c1(msg, options)
+      end
+
+      def pattern_section(msg)
+        if generating_program?
+          yield
+        else
+          step_comment(msg)
+          yield
+        end
+      end
+
+      def ss(msg = nil)
+        div = step_comment_prefix.length
+        div = 1 if div == 0
+        c1(step_comment_prefix * (70 / div))
+        @step_comment_on = true
+        if block_given?
+          yield
+        else
+          c1(msg)
+        end
+        @step_comment_on = false
+        c1(step_comment_prefix * (70 / div))
+      end
+
+      def snip(_number, _options = {})
+        yield
+      end
+
+      # Allows a section to be run without actually generating any vectors. This can be useful
+      # to ensure the pin states end up as they otherwise would have if the section had been run.
+      # Classic example of this is a subroutine pattern, wrap this around a call to the startup
+      # routine to ensure the pin states are as they would have been immediately after the startup.
+      # ==== Example
+      #   # Setup state as if I had run startup without actually doing so
+      #   $tester.inhibit_vectors_and_comments do
+      #       $soc.startup
+      #       $top.startup
+      #   end
+      def inhibit_vectors_and_comments
+        inhibit_vectors = @inhibit_vectors
+        inhibit_comments = @inhibit_comments
+        @inhibit_vectors = true
+        @inhibit_comments = true
+        yield
+        @inhibit_vectors = inhibit_vectors      # Restore to their initial state
+        @inhibit_comments = inhibit_comments
+      end
+
+      # @see inhibit_vectors_and_comments
+      def inhibit_vectors
+        inhibit_vectors = @inhibit_vectors
+        @inhibit_vectors = true
+        yield
+        @inhibit_vectors = inhibit_vectors      # Restore to their initial state
+      end
+
+      # @see inhibit_vectors_and_comments
+      def inhibit_comments
+        inhibit_comments = @inhibit_comments
+        @inhibit_comments = true
+        yield
+        @inhibit_comments = inhibit_comments
+      end
+
+      # Generate a vector.
+      # Calling this method will generate a vector in the output pattern based on the
+      # current pin states and timeset.
+      def cycle(options = {})
+        options = {
+          microcode: '',
+          timeset:   current_timeset,
+          pin_vals:  current_pin_vals,
+          repeat:    nil
+        }.merge(options)
+
+        if any_clocks_running?
+          update_running_clocks
+          if options[:repeat]
+            slice_repeats(options).each do |slice|
+              options[:repeat] = slice[0]
+              delay(options.delete(:repeat), options) do |options|
+                push_vector(options)
+              end
+              slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+              options[:pin_vals] = current_pin_vals
+            end
+          else
+            push_vector(options)
+            pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+          end
+        else
+          if options[:repeat]
+            delay(options.delete(:repeat), options) do |options|
+              push_vector(options)
+            end
+          else
+            push_vector(options)
+          end
+        end
+      end
+
+      def import_test_time(_file, _options = {})
+        puts "Sorry but an importer doesn't exist for: #{Origen.tester.class}"
+      end
+
+      def any_clocks_running?
+        @clocks_running.nil? ? false : @clocks_running.count > 0
+      end
+
+      def clocks_running
+        @clocks_running
+      end
+      alias_method :running_clocks, :clocks_running
+
+      def push_running_clock(pin)
+        @clocks_running.nil? ? @clocks_running = { pin.name.to_s => pin } : @clocks_running[pin.name.to_s] = pin
+      end
+
+      def pop_running_clock(pin)
+        fail "ERROR: No clocks running, doesn't make sense to pop one" unless any_clocks_running?
+        @clocks_running.delete(pin.name.to_s)
+      end
+
+      def slice_repeats(options = {})
+        slices = {}
+        repeat_ary = []
+        clocks_running.each do |name, clock_pin|
+          if clock_pin.next_edge < (cycle_count + options[:repeat])
+            pin_slices = (clock_pin.next_edge..(cycle_count + options[:repeat])).step(clock_pin.half_period).to_a
+            pin_slices.insert(0, cycle_count)
+          else
+            pin_slices = [cycle_count]
+          end
+          pin_slices.each do |cycle|
+            slices[cycle].nil? ? slices[cycle] = name : slices[cycle] = "#{slices[cycle]},#{name}"
+          end
+          slices[cycle_count + options[:repeat]] = '' if pin_slices[-1] != cycle_count + options[:repeat]
+        end
+        slices.keys.sort.each do |edge_cycles|
+          # puts "Toggle #{slices[edge_cycles]} on #{edge_cycles}"
+          repeat_ary.push([edge_cycles, slices[edge_cycles].split(',')])
+        end
+
+        (repeat_ary.count - 1).downto(1).each { |i| repeat_ary[i][0] = repeat_ary[i][0] - repeat_ary[i - 1][0] }
+        repeat_ary[1..-1]
+      end
+
+      def pins_need_toggling
+        toggle_ary = []
+        clocks_running.each do |name, clock_pin|
+          toggle_ary.push("#{name}") if clock_pin.next_edge == cycle_count
+        end
+        toggle_ary
+      end
+
+      def update_running_clocks
+        clocks_running.each do |_name, clock_pin|
+          clock_pin.update_clock
+        end
+      end
+    end
+  end
+end

data/lib/origen/tester/bdm/bdm.rb

@@ -0,0 +1,25 @@
+module Origen
+  module Tester
+    class BDM < CommandBasedTester
+      def initialize
+        super
+        # The minimum time unit is 0.1s
+        set_timeset('default', 100_000_000)
+        @pat_extension = 'cmd'
+        @comment_char = '//'
+      end
+
+      def delay(cycles)
+        microcode "WAIT #{cycles_to_ts(cycles)}"
+      end
+
+      def write_byte(address, data)
+        microcode "WB 0x#{address.to_s(16).upcase} 0x#{data.to_s(16).upcase}"
+      end
+
+      def write_word(address, data)
+        microcode "WW 0x#{address.to_s(16).upcase} 0x#{data.to_s(16).upcase}"
+      end
+    end
+  end
+end

data/lib/origen/tester/command_based_tester.rb

@@ -0,0 +1,46 @@
+module Origen
+  module Tester
+    # A base class that can be used to model command-based, rather than
+    # vector-based testers.
+    class CommandBasedTester
+      include Tester
+
+      def initialize
+        @vector_based = false
+      end
+
+      # Write a string directly to the output file without being processed
+      # or modified in any way
+      def direct_write(str)
+        microcode str
+      end
+      alias_method :dw, :direct_write
+
+      # Concept of a cycle not supported, print out an error to the output
+      # file to alert the user that execution has hit code that is not
+      # compatible with a command based tester.
+      def cycle(*_args)
+        microcode '*** Cycle called ***'
+      end
+
+      # Concept of a subroutine not supported, print out an error to the output
+      # file to alert the user that execution has hit code that is not
+      # compatible with a command based tester.
+      def call_subroutine(sub)
+        microcode "Call_subroutine called to #{sub}"
+      end
+
+      def format_vector(vec)
+        vec.microcode
+      end
+
+      # Loop the content embedded in the supplied block
+      def loop(_name = nil, number_of_loops)
+        number_of_loops.times do
+          yield
+        end
+      end
+      alias_method :loop_vector, :loop
+    end
+  end
+end