origen 0.0.1 → 0.0.2

data/lib/origen/tester/vector_pipeline.rb

@@ -0,0 +1,150 @@
+module Origen
+  module Tester
+    class VectorPipeline
+      attr_reader :group_size, :pipeline
+
+      def initialize(group_size)
+        @group_size = group_size
+        @pipeline = []
+      end
+
+      # Add a vector/comment to the pipeline
+      def <<(vector)
+        if vector.is_a?(Vector)
+          consume_comments(vector)
+          if vector.repeat > 1
+            add_repeat_vector(vector)
+          else
+            pipeline << vector
+          end
+        else
+          comments << vector
+        end
+      end
+
+      # If there are complete groups sitting at the top of the pipeline
+      # then this will yield them back line by line, stopping when after the last
+      # complete group and leaving any remaining single vectors in the pipeline
+      # If there are no complete groups present then it will just return
+      def flush
+        while lead_group_finalized?
+          lead_group.each do |vector|
+            vector.comments.each do |comment|
+              yield comment
+            end
+            yield vector
+          end
+          pipeline.shift(group_size)
+        end
+      end
+
+      # Call at the end to force a flush out of any remaining vectors
+      def empty
+        if !pipeline.empty? || !comments.empty?
+          pipeline.each do |vector|
+            vector.comments.each do |comment|
+              yield comment
+            end
+            yield vector
+          end
+          comments.each do |comment|
+            yield comment
+          end
+          @pipeline = []
+          @comments = []
+        end
+      end
+
+      private
+
+      # Pushes a duplicate of the given vector with its repeat set to 1
+      # Also clears any comments associated with the vector with the rationale that we only
+      # want to see them the first time
+      def push_duplicate(vector)
+        v = vector.dup
+        v.repeat = 1
+        pipeline << v
+        vector.comments = []
+      end
+
+      def add_repeat_vector(vector)
+        count = vector.repeat
+        # Align to the start of a new group by splitting off single vectors
+        # to complete the current group
+        while !aligned? && count > 0
+          push_duplicate(vector)
+          count -= 1
+        end
+        if count > group_size
+          remainder = count % group_size
+          # Create a group with the required repeat
+          group_size.times do
+            push_duplicate(vector)
+          end
+          pipeline.last.repeat = (count - remainder) / group_size
+          # Then expand out any leftover
+          remainder.times do
+            push_duplicate(vector)
+          end
+        # For small repeats that fit within the group just expand them
+        else
+          while count > 0
+            push_duplicate(vector)
+            count -= 1
+          end
+        end
+      end
+
+      # Returns true of the next vector to be added to the pipeline will
+      # be at the start of a new group
+      def aligned?
+        (pipeline.size % group_size) == 0
+      end
+
+      def consume_comments(vector)
+        vector.comments = comments
+        @comments = []
+      end
+
+      def comments
+        @comments ||= []
+      end
+
+      # When true the lead group is complete and a further repeat of it is not possible
+      # Calling this will compress the 2nd group into the 1st if possible
+      def lead_group_finalized?
+        if lead_group.size == group_size
+          if second_group_present?
+            i = -1
+            if second_group.all? do |vector|
+                 i += 1
+                 pipeline[i] == vector
+               end
+              pipeline[group_size - 1].repeat += 1
+              group_size.times { pipeline.delete_at(group_size) }
+              false
+            else
+              true
+            end
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def second_group_present?
+        second_group.size == group_size
+      end
+
+      def lead_group
+        pipeline[0..group_size - 1]
+      end
+
+      def second_group
+        pipeline[group_size..(group_size * 2) - 1]
+      end
+    end
+  end
+end

data/lib/origen/tester.rb

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

@@ -0,0 +1,134 @@
+require 'active_support/concern'
+module Origen
+  # Include this module to identify it as a top-level object in Origen, normally
+  # an object that represents the SoC/Top-level device.
+  #
+  # Origen will then fallback on this top-level object to service any register
+  # read/write requests or any pin requests that are generated by lower
+  # level objects and which cannot be fulfilled at that level.
+  #
+  # The current top level object can then be referenced at any time via
+  # Origen.top_level.
+  module TopLevel
+    extend ActiveSupport::Concern
+
+    included do
+      # Any pattern compilation or other operation that requires access to a pinmap
+      # will look for it via this attribute, this should return a path to the pinmap
+      # file to be used
+      attr_accessor :pinmap
+
+      # Store the current pattern compiler instance name
+      attr_accessor :compiler
+
+      include Origen::Model
+    end
+
+    def reset!
+      reset bang: true
+    end
+
+    def pinmap=(val)
+      @pinmap = Pathname.new(val)
+    end
+
+    def reset(options = {})
+      Origen.app.listeners_for(:before_top_level_reset).each(&:before_top_level_reset)
+      if options[:bang]
+        Origen.app.listeners_for(:shutdown, top_level: :last).each do |listener|
+          listener.shutdown(Pattern.create_options)
+        end
+        Origen.app.listeners_for(:on_top_level_reset!, top_level: false).each(&:on_top_level_reset!)
+      end
+      Origen.app.listeners_for(:on_top_level_reset, top_level: false).each(&:on_top_level_reset)
+      Origen.app.listeners_for(:reset_registers).each(&:reset_registers)
+      if options[:bang]
+        Origen.app.listeners_for(:startup).each do |listener|
+          listener.startup(Pattern.create_options)
+        end
+      end
+      Origen.app.listeners_for(:after_top_level_reset).each(&:after_top_level_reset)
+    end
+
+    def ip_name
+      @ip_name || self.class.to_s.split('::').last.symbolize
+    end
+
+    # Use this to specify the current package option for the given SoC.
+    #
+    # This allows different pin configurations to be specified by package.
+    def current_package=(val)
+      @current_package_id = val.is_a?(ChipPackage) ? val.id : val
+    end
+    alias_method :package=, :current_package=
+
+    # Returns the current package configuration of the pin owner, unless specifically
+    # specified by the application this will return nil.
+    def current_package(_options = {})
+      if @current_package_id
+        return _packages[@current_package_id] if _packages[@current_package_id]
+        fail "The package #{@current_package_id} of #{self.class} has not been defined!"
+      end
+    end
+    alias_method :package, :current_package
+
+    # Returns an array containing the IDs of all known configurations if no ID is supplied,
+    # otherwise returns an object representing the given package ID
+    def packages(id = nil, _options = {})
+      id, options = nil, id if id.is_a?(Hash)
+      if id
+        _packages[id]
+      else
+        _packages.ids
+      end
+    end
+
+    # Execute the supplied block within the context of the given package, at the end
+    # the model's package attribute will be restored to what it was before calling
+    # this method.
+    def with_package(id, _options = {})
+      orig = package
+      self.package = id
+      yield
+      self.package = orig
+    end
+
+    def add_package(id, _options = {})
+      p = ChipPackage.new
+      p.id = id
+      p.owner = self
+      yield p if block_given?
+      _add_package(p)
+      p
+    end
+
+    def includes_origen_top_level?
+      true
+    end
+
+    # Sets the Origen.top_level.packages array to nil.  Written so packages created in memory can
+    # be erased so packages defined in Ruby files can be loaded
+    def delete_all_packages
+      @_packages = nil
+    end
+    alias_method :delete_all_pkgs, :delete_all_packages
+
+    private
+
+    def init_top_level
+      Origen.app.add_toplevel_listener(self)
+    end
+
+    def _packages
+      @_packages ||= {}
+    end
+
+    def _add_package(package)
+      if _packages[package.id]
+        fail "There is already a package called #{package.id}!"
+      else
+        _packages[package.id] = package
+      end
+    end
+  end
+end

data/lib/origen/users/ldap.rb

@@ -0,0 +1,65 @@
+module Origen
+  module Users
+    # Interface to talk to a company's LDAP-based employee directory, an instance of this class is available
+    # at Origen.ldap
+    #
+    # This provides APIs to lookup public information about any user (email, phone number, etc)
+    class LDAP
+      require 'io/console'
+      require 'base64'
+      require 'net-ldap'
+
+      SERVICE_ACCOUNT = Origen.site_config.ldap_username
+      SERVICE_PASS = Origen.site_config.ldap_password
+
+      HOST = Origen.site_config.ldap_host
+      PORT = Origen.site_config.ldap_port
+      BASE_DN = Origen.site_config.ldap_base_dn
+
+      def available?
+        !!(SERVICE_ACCOUNT && SERVICE_PASS && HOST && PORT && BASE_DN)
+      end
+
+      # Lookup the given user in the core directory and return an object representing the user's entry
+      # in the FSL application directory, run the display method from the console to see the field
+      # names and what information is available.
+      # The record for the given user will be cached the first time it is generated, so this method can be
+      # repeatedly called from the same thread without incurring a remote fetch each time.
+      #
+      #     entry = Origen.fsl.lookup("r49409")
+      #     entry.mail   # => stephen.mcginty@freescale.com
+      def lookup(user_or_id = Origen.current_user)
+        id = id(user_or_id)
+        unless instance_variable_defined?("@#{id.downcase}")
+          record = service.search(base: BASE_DN, filter: "#{Origen.site_config.ldap_user_id_attribute || 'id'}=#{id}").first
+          instance_variable_set("@#{id.downcase}", record)
+        end
+        instance_variable_get("@#{id.downcase}")
+      end
+
+      # Prints out the information available for the given core, this is useful to work out the name
+      # of the information that you want to pull from the object returned from lookup
+      def display(user_or_id = Origen.current_user)
+        lookup(user_or_id).each do |attribute, values|
+          puts "   #{attribute}:"
+          values.each do |value|
+            puts "      --->#{value}"
+          end
+        end
+      end
+
+      private
+
+      def id(user_or_id)
+        user_or_id.respond_to?(:id) ? user_or_id.id : user_or_id
+      end
+
+      def service
+        @service ||= Net::LDAP.new host:       HOST,
+                                   port:       PORT,
+                                   encryption: :simple_tls,
+                                   auth:       { method: :simple, username: SERVICE_ACCOUNT, password: SERVICE_PASS }
+      end
+    end
+  end
+end

data/lib/origen/users/user.rb

@@ -0,0 +1,149 @@
+module Origen
+  module Users
+    class User
+      require 'openssl'
+      require 'digest/sha1'
+
+      attr_reader :role
+      attr_writer :name, :email
+
+      def self.current_user_id
+        `whoami`.strip
+      end
+
+      def self.current
+        Origen.current_user
+      end
+
+      def initialize(*args)
+        if args.last.is_a?(Symbol)
+          @role = args.pop
+        else
+          @role = :user
+        end
+        if args.size == 2
+          @name = args.first
+        end
+        id = args.pop
+        if id.to_s =~ /(.*)@/
+          @email = id
+          @id = Regexp.last_match(1)
+        else
+          @id = id
+        end
+      end
+
+      # Send the user an email
+      #
+      # @example
+      #   User.current.send subject: "Complete", message: "Your job is done!"
+      #   User.new("r49409").send subject: "Complete", message: "Your job is done!"
+      def send(options)
+        options[:body] ||= options[:message]
+        options[:to] = self
+        Origen.mailer.send_email(options)
+      end
+
+      def id
+        @id.to_s.downcase
+      end
+      alias_method :core_id, :id
+
+      # Returns true if the user is an admin for the current application
+      def admin?
+        role == :admin
+      end
+
+      # Returns true if the user is the current user
+      def current?
+        id.to_s.downcase == self.class.current_user_id
+      end
+
+      # Returns the user's initials in lower case
+      def initials
+        initials = name.split(/\s+/).map { |n| n[0].chr }.join('')
+        initials.downcase
+      end
+
+      def name
+        @name || @id
+      end
+
+      def email
+        return @email if @email
+        if Origen.site_config.email_domain
+          "#{id}@#{Origen.site_config.email_domain}"
+        end
+      end
+
+      # Fetch user data from the FSL application directory
+      #
+      # @example
+      #
+      #   User.new("r49409").lookup.motunixdomain   # => ["cde-tx32.sps.mot.com"]
+      def lookup(default = 'Unknown')
+        data = Origen.ldap.lookup(self)
+        if block_given?
+          if data
+            yield data
+          else
+            default
+          end
+        else
+          data
+        end
+      end
+
+      # Prints all raw data available on the given user from the FSL
+      # application directory.
+      #
+      # Most of the useful data is already exposed through the available
+      # user methods, but if you want to get any of these parameters they
+      # can be fetched via the lookup method.
+      def raw
+        Origen.ldap.display(self)
+        nil
+      end
+      alias_method :display, :raw
+
+      def ==(user)
+        if user.is_a?(Origen::Users::User)
+          user.id == id
+        elsif user.is_a?(String)
+          user.downcase == id
+        else
+          super
+        end
+      end
+
+      # Provides methods to access attributes available from LDAP
+      def method_missing(method, *args, &block)
+        l = Origen.ldap.lookup(self)
+        if l
+          if l.attribute_names.include?(method)
+            l[method]
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(method)
+        super || begin
+          if Origen.ldap.available?
+            Origen.ldap.lookup(self) && Origen.ldap.lookup(self).attribute_names.include?(method.to_sym)
+          else
+            false
+          end
+        end
+      end
+
+      # Returns a string like "Stephen McGinty <Stephen.Mcginty@freescale.com>"
+      def name_and_email
+        "#{name} <#{email}>"
+      end
+    end
+  end
+end

data/lib/origen/users.rb

@@ -0,0 +1,30 @@
+module Origen
+  # Methods related to individual users and groups
+  module Users
+    autoload :User,   'origen/users/user'
+    autoload :LDAP,   'origen/users/ldap'
+
+    def app_users
+      # Had to do some shenanigans here due to Origen.root not being available
+      # when this file is included, only load the users from the app once a user
+      # method is first called
+      return @app_users if @app_users
+      require File.join(Origen.root, 'config', 'users')
+      @app_users = users
+    end
+
+    # Returns a user object representing the current user, will return a default
+    # user object if the current user is not known to the generator
+    def current_user
+      core_id = Origen::Users::User.current_user_id
+      user = app_users.find { |user| user.core_id == core_id }
+      user || User.new(core_id)
+    end
+
+    # Returns all admin user objects
+    def admins
+      app_users.select(&:admin?)
+    end
+    alias_method :developers, :admins
+  end
+end

data/lib/origen/utility/block_args.rb

@@ -0,0 +1,93 @@
+module Origen
+  module Utility
+    # BlockArgs provides a neat way to pass multiple block arguments to a method
+    # that the method can then used in various ways.
+    #
+    # (blocks in Ruby are merely nameless methods you can pass to methods as an argument. Used to pass ruby code to a method basically.)
+    #
+    # A single BlockArgs object is an array of these blocks that can be added or
+    # deleted.
+    #
+    #   def handle_some_blocks(options={})
+    #
+    #     blockA = Origen::Utility::BlockArgs.new
+    #     blockB = Origen::Utility::BlockArgs.new
+    #
+    #     yield blockA, blockB
+    #
+    #     puts "Handling blocks!"
+    #
+    #     if options[:block_to_run] == :blockA
+    #       blockA.each do |block|
+    #         block.call
+    #       end
+    #     else
+    #       blockB.each do |block|
+    #         block.call
+    #       end
+    #     end
+    #
+    #     puts "Done handling blocks!"
+    #
+    #   end
+    #
+    # To then use the above method:
+    #
+    #   handle_some_blocks(options) do |blockA, blockB|
+    #     blockA.add do
+    #       puts "do task 1"
+    #     end
+    #     blockA.add do
+    #       puts "do task 2"
+    #     end
+    #     blockB.add do
+    #       puts "do task 3"
+    #     end
+    #   end
+    #
+    # Many blocks can be added in this case to either the blockA or blockB BlockArg objects.
+    # The only reason 2 BlockArg objects are used above is that handle_some_blocks wants to use
+    # different blocks depending on an option argument.
+    #
+    # This is a very powerful way to put code specific to one application in a different method in
+    # different class (e.g. handle_some_blocks) where the code calling it doesn't need to know
+    # exact implementation details.
+    #
+    class BlockArgs
+      # any Enumerable methods also can be used
+      # e.g. each_with_index
+      include Enumerable
+
+      # Creates a new BlockArgs object
+      def initialize
+        @block_args = []
+      end
+
+      # Adds a block to the BlockArgs object
+      def add(&block)
+        @block_args << block
+      end
+
+      # Deletes a block to the BlockArgs object
+      def delete(&block)
+        @block_args.delete(block)
+      end
+
+      # required to enumerate objects for Enumerable
+      # iterator returns each block at a time
+      def each
+        @block_args.each do |arg|
+          yield arg
+        end
+      end
+
+      # same as each but returns index of each block
+      # instead of block itself.
+      def each_index
+        @block_args.each_index do |i|
+          yield i
+        end
+      end
+    end
+  end
+end