origen 0.2.6 → 0.3.0

data/lib/origen/nvm.rb

@@ -1,6 +0,0 @@
-module Origen
-  # Module containing helpers to support NVM testing
-  module NVM
-    autoload :BlockArray,  'origen/nvm/block_array'
-  end
-end

data/lib/origen/nvm/block_array.rb

@@ -1,72 +0,0 @@
-module Origen
-  module NVM
-    # A block array is a standard Ruby array that has been enhanced with additional
-    # methods related to the fact that it is intended to hold NVM block objects.
-    #
-    # This for example allows a block select value to be automatically generated for
-    # whatever blocks are contained in the array by calling the bsel method.
-    class BlockArray < ::Array
-      # Return all single blocks wrapped in a block array
-      def [](ix)
-        BlockArray.new << super(ix)
-      end
-
-      # Extract a subset of blocks based on ids
-      #
-      #   $nvm.blocks.find(0,3)
-      #
-      # An elegant way to implement this is via an accessor like this on your top-level
-      # object which owns the blocks:
-      #
-      #   def blocks(*args)
-      #     if args.empty?
-      #       @blocks
-      #     else
-      #       @blocks.find(*args)
-      #     end
-      #   end
-      #   alias :block :blocks
-      #
-      # This provides the following API:
-      #
-      #   $nvm.blocks        # Returns all blocks
-      #   $nvm.block(0)      # Returns block 0 wrapped in a block array
-      #   $nvm.blocks(0, 3)  # Returns blocks 0 and 3 wrapped in a block array
-      def find(*ids)
-        b = BlockArray.new
-        ids.each do |id|
-          b << self[id]
-        end
-        b
-      end
-
-      # def method_missing(method, *args, &blk)
-      #  if self.size == 1
-      #    self.first.send(method, *args, &blk)
-      #  else
-      #    super
-      #  end
-      # end
-
-      # Returns the block select value required to select all contained blocks, the block object
-      # must implement a method called bsel for this to work
-      def bsel
-        reduce(0) { |bsels, block| bsels | block.bsel }
-      end
-      alias_method :block_select, :bsel
-      alias_method :block_select_value, :bsel
-
-      # Returns the sum of the size of all contained blocks in KB, the block object must implement
-      # a method called size_in_kb for this to work
-      def size_in_kb
-        reduce(0) { |sum, block| sum + block.size_in_kb }
-      end
-
-      # Returns the sum of the size of all contained blocks in bytes, the block object must implement
-      # a method called size_in_kb for this to work
-      def size_in_bytes
-        size_in_kb * 1024
-      end
-    end
-  end
-end

data/lib/origen/tester.rb

@@ -1,56 +0,0 @@
-require 'active_support/concern'
-module Origen
-  module Tester
-    autoload :J750,      'origen/tester/j750/j750'
-    autoload :J750_HPT,  'origen/tester/j750/j750_hpt'
-    autoload :Ultraflex, 'origen/tester/ultraflex/ultraflex'
-    autoload :V93K,      'origen/tester/v93k/v93k'
-    autoload :BDM,       'origen/tester/bdm/bdm'
-    autoload :JLink,     'origen/tester/jlink/jlink'
-    autoload :Doc,       'origen/tester/doc/doc'
-
-    autoload :Vector,         'origen/tester/vector'
-    autoload :VectorPipeline, 'origen/tester/vector_pipeline'
-    autoload :CommandBasedTester, 'origen/tester/command_based_tester'
-    autoload :Interface, 'origen/tester/interface'
-    autoload :Generator, 'origen/tester/generator'
-    autoload :Parser,    'origen/tester/parser'
-    autoload :Time,      'origen/tester/time'
-
-    extend ActiveSupport::Concern
-
-    require 'origen/tester/vector_generator'
-    require 'origen/tester/timing'
-    require 'origen/tester/api'
-
-    include VectorGenerator
-    include Timing
-    include API
-
-    included do
-    end
-
-    module ClassMethods # :nodoc:
-      # This overrides the new method of any class which includes this
-      # module to force the newly created instance to be registered as
-      # a tester with Origen
-      def new(*args, &block) # :nodoc:
-        if Origen.app.with_doc_tester?
-          x = Origen::Tester::Doc.allocate
-          if Origen.app.with_html_doc_tester?
-            x.html_mode = true
-          end
-        else
-          x = allocate
-        end
-        x.send(:initialize, *args, &block)
-        x.register_tester
-        x
-      end
-    end
-
-    def register_tester # :nodoc:
-      Origen.app.tester = self
-    end
-  end
-end

data/lib/origen/tester/api.rb

@@ -1,277 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/doc/doc.rb

@@ -1,226 +0,0 @@
-module Origen
-  module Tester
-    # Tester model to generate test program documentation from your pattern sources.
-    # This is intended to be a drop in replacement for existing testers and instead
-    # of generating patterns or test program sheets it will generate a document object
-    # which you can then render out via a template or manually.
-    class Doc
-      include Tester
-
-      autoload :Generator, 'origen/tester/doc/generator'
-      autoload :Model, 'origen/tester/doc/model'
-
-      attr_accessor :html_mode
-
-      def generate?
-        html_mode
-      end
-
-      def initialize(*_args)
-        @pat_extension = 'md'
-        @indent = 0
-        @snip_counters = []
-      end
-
-      # Snip the number of comment lines generated by the contained block
-      # to the number given, this is useful for keeping files sizes down and
-      # is typically used to snip sections like downloading LRE code.
-      def snip(number, _options = {})
-        @snip_counters.push number + 1
-        yield
-        @snip_counters.pop
-      end
-
-      def pc(msg)
-        if @snip_counters.last
-          if @snip_counters.last == 1
-            @snip_counters[@snip_counters.size - 1] = 0
-            msg = '  ...snipped'
-          elsif @snip_counters.last == 0
-            return
-          else
-            @snip_counters[@snip_counters.size - 1] -= 1
-          end
-        end
-        if html_mode
-          push_comment(msg)
-        else
-          Origen.log.info((' ' * @indent) + msg)
-        end
-      end
-
-      def c1(msg, options = {})
-        if generating_program?
-          Origen.interface.doc_comments_capture(msg)
-        else
-          unless @inhibit_comments
-            options = {
-              prefix: true
-            }.merge(options)
-            if @step_comment_on
-              open_text_block
-              if options[:prefix]
-                pc "# #{msg}"
-              else
-                pc "#{msg}"
-              end
-            end
-          end
-        end
-      end
-
-      def c2(msg, options = {})
-        unless @inhibit_comments
-          options = {
-            prefix: true
-          }.merge(options)
-          open_text_block
-          if options[:prefix]
-            pc "# #{msg}"
-          else
-            pc "#{msg}"
-          end
-        end
-      end
-
-      def annotate(msg, _options)
-        unless @inhibit_comments
-          if html_mode
-            pc ''
-            lines = msg.split("\n")
-            leading_spaces = lines.first[/\A */].size
-            lines.each do |line|
-              pc line.gsub(/^.{#{leading_spaces}}/, '')
-            end
-            pc ''
-          end
-        end
-      end
-
-      def open_text_block
-        if html_mode
-          unless @text_block_open
-            pc ''
-            pc '~~~text'
-            @text_block_open = true
-          end
-        end
-      end
-
-      def close_text_block
-        if html_mode
-          if @text_block_open
-            pc '~~~'
-            pc ''
-            @text_block_open = false
-          end
-        end
-      end
-
-      def pattern_name
-        Origen.app.current_job.output_pattern_filename.gsub('.md', '')
-      end
-
-      def pre_header
-        # pc "---"
-        # pc "layout: bootstrap"
-        # pc "title: #{pattern_name}"
-        # pc "gzip: false"
-        # pc "---"
-        # pc ""
-        # pc "# #{pattern_name}"
-        # pc ""
-      end
-
-      def pattern_section(msg)
-        unless @inhibit_comments
-          if generating_program?
-            Origen.interface.flow.start_section(name: msg)
-            yield
-            Origen.interface.flow.stop_section
-          else
-            if html_mode
-              counter = next_accordion_counter
-              close_text_block
-              pc ''
-              pc "<div class=\"accordion-group\">"
-              pc "<div class=\"accordion-heading\">"
-              pc "<a class=\"accordion-toggle\" data-toggle=\"collapse\" data-parent=\"#accordion2\" href=\"#collapseComment#{counter}\">"
-              pc "#{msg}"
-              pc '</a>'
-              pc '</div>'
-              pc "<div id=\"collapseComment#{counter}\" class=\"accordion-body collapse\">"
-              pc "<div class=\"accordion-inner\" markdown=\"1\">"
-              yield
-              close_text_block
-              pc '</div>'
-              pc '</div>'
-              pc '</div>'
-            else
-              pc ''
-              pc "#{msg}"
-              pc ''
-              @indent += 4
-              yield
-              @indent -= 4
-            end
-          end
-        end
-      end
-
-      def next_accordion_counter
-        @accordion_counter ||= 0
-        @accordion_counter += 1
-      end
-
-      def ss(msg = nil)
-        unless @inhibit_comments
-          @step_comment_on = true
-          if block_given?
-            yield
-          else
-            c2(msg)
-          end
-          @step_comment_on = false
-        end
-      end
-
-      def self.generate_program_model(files, options = {})
-        options = {
-          action:       :program,
-          return_model: true,
-          skip_diff:    true
-        }.merge(options)
-        Origen.app.with_doc_tester do
-          Origen.target.temporary = options[:target] if options[:target]
-          Origen.app.load_target!
-          Origen.interface.reset_globals
-          options[:files] = files
-          Origen.file_handler.preserve_and_clear_state do
-            Origen.app.runner.launch(options)
-          end
-        end
-        model.target = Origen.target.name
-        model
-      end
-
-      def self.model
-        @model ||= Model.new
-      end
-
-      def doc?
-        true
-      end
-
-      def cycle(_options = {})
-      end
-
-      # Ignore any tester-specific methods
-      def method_missing(_method, *_args, &_block)
-        if block_given?
-          yield
-        end
-      end
-    end
-  end
-end