origen 0.0.1 → 0.0.2

data/lib/origen/location/map.rb

@@ -0,0 +1,83 @@
+require 'active_support/concern'
+module Origen
+  module Location
+    module Map
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def define_locations(defaults = {})
+          @x = @x ? (@x + 1) : 0  # Provides a unique ID for each define_locations block
+          default_attributes[@x] = defaults
+          @defining = true
+          yield
+          @defining = false
+        end
+
+        def constructor(&block)
+          if defining?
+            constructors[@x] = block
+          else
+            constructors[:default] = block
+          end
+        end
+
+        def default_constructor(attributes, defaults)
+          Origen::Location::Base.new(defaults.merge(attributes))
+        end
+
+        def definitions
+          @definitions ||= {}
+        end
+
+        def constructors
+          @constructors ||= {}
+        end
+
+        def default_attributes
+          @default_attributes ||= {}
+        end
+
+        def defining?
+          @defining
+        end
+
+        # A hash of constructed location objects, i.e. an entry will be cached here the first time a location
+        # is referenced outside of its initial definition, after that it will be served directly from here.
+        def constructed
+          @constructed ||= {}
+        end
+
+        # Provides accessors for all named locations, for example:
+        #
+        #   $dut.nvm.fmu.ifr_map.probe1_pass
+        def method_missing(method, *args, &block)
+          if defining?
+            if definitions[method]
+              warning "Redefinition of map location: #{method}"
+            end
+            definitions[method] = { attributes: args.first, x: @x }
+          else
+            super
+          end
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        klass = self.class
+        klass.constructed[method] || begin
+          definition = klass.definitions[method]
+          if definition
+            defaults = klass.default_attributes[definition[:x]] || {}
+            constructor = klass.constructors[definition[:x]] || klass.constructors[:default]
+            if constructor
+              instance = constructor.call(definition[:attributes], defaults)
+            else
+              instance = klass.default_constructor(definition[:attributes], defaults)
+            end
+            klass.constructed[method] = instance
+          end
+        end || super
+      end
+    end
+  end
+end

data/lib/origen/location.rb

@@ -0,0 +1,6 @@
+module Origen
+  module Location
+    autoload :Map,  'origen/location/map'
+    autoload :Base, 'origen/location/base'
+  end
+end

data/lib/origen/log.rb

@@ -0,0 +1,217 @@
+module Origen
+  # An instance of this class is instantiated as Origen.log and provides the following API
+  #
+  # @example
+  #   log.error "Blah"     # Error message, always shown
+  #   log.debug "Blah"     # Debug message, only shown when in verbose mode
+  #   log.info  "Blah"     # Info message, always shown
+  #   log.warn  "Blah"     # Warning message, always shown
+  #   log.deprecate "Blah" # Deprecate message, always shown
+  class Log
+    require 'colored'
+    require 'log4r'
+    require 'log4r/outputter/fileoutputter'
+
+    LEVELS = [:normal, :verbose, :silent]
+
+    def initialize
+      @log_time_0 = @t0 = Time.new
+      self.level = :normal
+    end
+
+    def console_only?
+      self.class.console_only? || !Origen.app
+    end
+
+    # Anything executed within the given block will log to the console only
+    #
+    # @example
+    #
+    #   Origen::Log.console_only do
+    #     Origen.log.info "This will not appear in the log file!"
+    #   end
+    def self.console_only
+      @console_only = true
+      yield
+      @console_only = false
+    end
+
+    def self.console_only=(val)
+      @console_only = val
+    end
+
+    def self.console_only?
+      @console_only
+    end
+
+    # Set the logger level, for valid values see LEVELS
+    def level=(val)
+      unless LEVELS.include?(val)
+        fail "Unknown log level, valid values are: #{LEVELS}"
+      end
+      # Map the log4r levels to our simplified 3 level system
+      # log4r level order is DEBUG < INFO < WARN < ERROR < FATAL
+      case val
+      when :normal
+        # Output everything except debug statements
+        console.level = Log4r::INFO
+        # Output everything
+        log_files.level = Log4r::DEBUG unless console_only?
+      when :verbose
+        console.level = Log4r::DEBUG
+        log_files.level = Log4r::DEBUG unless console_only?
+      when :silent
+        # We don't use any fatal messages, so this is effectively OFF
+        console.level = Log4r::FATAL
+        log_files.level = Log4r::DEBUG unless console_only?
+      end
+
+      @level = val
+    end
+
+    # Returns the current logger level
+    def level
+      @level
+    end
+
+    def debug(string = '')
+      msg = format_msg('DEBUG', string)
+      log_files.debug msg unless console_only?
+      console.debug msg
+      nil
+    end
+
+    def info(string = '')
+      msg = format_msg('INFO', string)
+      log_files.info msg unless console_only?
+      console.info msg
+      nil
+    end
+    # Legacy methods
+    alias_method :lputs, :info
+    alias_method :lprint, :info
+
+    def success(string = '')
+      msg = format_msg('SUCCESS', string)
+      log_files.info msg unless console_only?
+      console.info msg.green
+      nil
+    end
+
+    def deprecate(string = '')
+      msg = format_msg('DEPRECATED', string)
+      log_files.warn msg unless console_only?
+      console.warn msg.yellow
+      nil
+    end
+    alias_method :deprecated, :deprecate
+
+    def warn(string = '')
+      msg = format_msg('WARNING', string)
+      log_files.warn msg unless console_only?
+      console.warn msg.yellow
+      nil
+    end
+    alias_method :warning, :warn
+
+    def error(string = '')
+      msg = format_msg('ERROR', string)
+      log_files.error msg unless console_only?
+      console.error msg.red
+      nil
+    end
+
+    # Made these all class methods so that they can be read without
+    # instantiating a new logger (mainly for use by the origen save command)
+    def self.log_file
+      "#{log_file_directory}/last.txt"
+    end
+
+    def self.rolling_log_file
+      "#{log_file_directory}/rolling.txt"
+    end
+
+    def self.log_file_directory
+      @log_file_directory ||= begin
+        dir = Origen.config.log_directory
+        FileUtils.mkdir_p dir unless File.exist?(dir)
+        dir
+      end
+    end
+
+    def silent?
+      level == :silent
+    end
+
+    def verbose?
+      level == :verbose
+    end
+
+    # Force logger to write any buffered output
+    def flush
+      if Origen.app
+        log_files.outputters.each(&:flush)
+      end
+      console.outputters.each(&:flush)
+    end
+
+    private
+
+    # Returns a Log4r instance that will send to the console
+    def console
+      @console ||= begin
+        console = Log4r::Logger.new 'console'
+        # console.level = QUIET
+        out = Log4r::Outputter.stdout
+        out.formatter = format
+        console.outputters << out
+        console
+      end
+    end
+
+    # Returns a Log4r instance that will send to the log files
+    def log_files
+      @log_files ||= begin
+        log_files = Log4r::Logger.new 'log_files'
+        # log_files.level = QUIET
+        file = Log4r::FileOutputter.new('fileOutputter', filename: self.class.log_file, trunc: true)
+        file.formatter = format
+        log_files.outputters << file
+        unless Origen.running_remotely?
+          rolling_file = Log4r::RollingFileOutputter.new('rollingfileOutputter', filename: self.class.rolling_log_file, trunc: false, maxsize: 5_242_880, max_backups: 10)
+          rolling_file.formatter = format
+          log_files.outputters << rolling_file
+        end
+        log_files
+      end
+    end
+
+    def relog(msg)
+      if msg =~ /^\[(\w+)\] .*/
+        method = Regexp.last_match(1).downcase
+        if respond_to?(method)
+          send method, msg.sub(/.*\|\|\s*/, '')
+        else
+          info msg
+        end
+      else
+        info msg
+      end
+    end
+
+    def format_msg(type, msg)
+      log_time_1 = Time.new
+      delta_t = (log_time_1.to_f - @log_time_0.to_f).round(6)
+      delta_t = '%0.3f' % delta_t
+      delta_t0 = (log_time_1.to_f - @t0.to_f).round(6)
+      delta_t0 = '%0.3f' % delta_t0
+      msg = "[#{type}]".ljust(13) + "#{delta_t0}[#{delta_t}]".ljust(16) + "|| #{msg}"
+      @log_time_0 = log_time_1
+      msg
+    end
+
+    def format
+      Log4r::PatternFormatter.new(pattern: '%m')
+    end
+  end
+end

data/lib/origen/logger_methods.rb

@@ -0,0 +1,56 @@
+module Origen
+  module LoggerMethods
+    extend ActiveSupport::Concern
+
+    included do |klass|
+      Origen.deprecate <<-END
+The LoggerMethods module is deprecated, use Origen.log instead (or just
+log from within a class that includes Origen::Model). See here for the new API:
+http://origen.freescale.net/origen/latest/guides/utilities/logger/
+Called from the #{klass} class.
+END
+    end
+
+    def log
+      @log ||= Origen.log
+    end
+
+    def lputs(*args)
+      Origen.log.lputs(*args)
+    end
+    alias_method :lprint, :lputs
+
+    def warn(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |arg| Origen.log.warn arg }
+    end
+    alias_method :warning, :warn
+
+    def error(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |arg| Origen.log.error arg }
+    end
+
+    def alert(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |arg| Origen.log.warn arg }
+    end
+
+    def deprecated(*lines)
+      options = lines.last.is_a?(Hash) ? lines.pop : {}
+      lines.flatten.each do |line|
+        line.split(/\n/).each do |line|
+          Origen.log.deprecate line
+        end
+      end
+    end
+
+    def highlight
+      lputs ''
+      lputs '######################################################################'
+      yield
+      lputs '######################################################################'
+      lputs ''
+    end
+  end
+end

data/lib/origen/mode.rb

@@ -0,0 +1,61 @@
+module Origen
+  # A class to handle the Origen execution mode
+  class Mode
+    MODES = [:production, :debug, :simulation]
+
+    def initialize(_options = {})
+      @current_mode = :production
+    end
+
+    # When called any future changes to the mode will be ignored
+    def freeze
+      @frozen = true
+    end
+
+    def unfreeze
+      @frozen = false
+    end
+
+    def set(val)
+      @current_mode = find_mode(val) unless @frozen
+    end
+
+    def find_mode(name)
+      name = name.to_s.downcase.to_sym
+      if MODES.include?(name)
+        name
+      else
+        mode = MODES.find do |m|
+          m.to_s =~ /^#{name}/
+        end
+        if mode
+          mode
+        else
+          fail "Invalid mode requested, must be one of: #{MODES}"
+        end
+      end
+    end
+
+    # Any mode which is not production will return true here, if
+    # you want to test for only debug mode use Origen.mode == :debug
+    def debug?
+      !production?
+    end
+
+    def production?
+      @current_mode == :production
+    end
+
+    def simulation?
+      @current_mode == :simulation
+    end
+
+    def ==(val)
+      if val.is_a?(Symbol)
+        @current_mode == val
+      else
+        super
+      end
+    end
+  end
+end

data/lib/origen/model.rb

@@ -0,0 +1,267 @@
+require 'active_support/concern'
+module Origen
+  # Include this module to identify it as an SoC IP Block, this will automatically
+  # include common modules such as Pin and Register support
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :ip_name
+      attr_accessor :version
+      attr_reader :controller
+
+      include Origen::ModelInitializer
+      include Origen::Pins
+      include Origen::Registers
+      include Origen::Callbacks
+      include Origen::Bugs
+      include Origen::Features
+      include Origen::SubBlocks
+      include Origen::Parameters
+      include Origen::Specs
+    end
+
+    module ClassMethods
+      def includes_origen_model
+        true
+      end
+    end
+
+    def log
+      Origen.log
+    end
+
+    def write_memory(*args)
+      return super if defined?(super)
+      write_register(*args)
+    end
+
+    def read_memory(*args)
+      return super if defined?(super)
+      read_register(*args)
+    end
+
+    def ip_name
+      @ip_name || self.class.to_s.split('::').last.symbolize
+    end
+
+    def wrap_in_controller
+      c = Origen.controllers.find do |params|
+        self.is_a?(params[:model_class]) if params[:model_class]
+      end
+      if c
+        c = c[:controller_class].send(:allocate)
+        if c.method(:initialize).arity == 0
+          c.send(:initialize)
+        else
+          c.send(:initialize, self)
+        end
+        c.send('_model=', self)
+        @controller = c
+        c
+      else
+        controller_class = _resolve_controller_class
+        if controller_class
+          c = controller_class.send(:allocate)
+          if c.method(:initialize).arity == 0
+            c.send(:initialize)
+          else
+            c.send(:initialize, self)
+          end
+          c.extend(Origen::Controller)
+          c.send('_model=', self)
+          @controller = c
+          c
+        else
+          self
+        end
+      end
+    end
+
+    def _resolve_controller_class
+      klass = self.class
+      while klass != Object
+        model_class = klass.to_s.split('::').last
+        controller_class = "#{model_class}Controller"
+        if eval("defined? #{controller_class}")
+          return eval(controller_class)
+        elsif eval("defined? ::#{controller_class}")
+          return eval("::#{controller_class}")
+        end
+        klass = klass.superclass
+      end
+    end
+
+    def current_configuration
+      if self.respond_to?(:configuration)
+        configuration
+      end
+    end
+
+    def configuration=(id)
+      add_configuration(id)
+      @configuration = id
+    end
+
+    def configuration
+      @configuration
+    end
+
+    def add_configuration(id)
+      configurations << id unless configurations.include?(id)
+    end
+
+    # Returns an array containing the IDs of all known configurations
+    def configurations
+      @configurations ||= []
+    end
+
+    # Execute the supplied block within the context of the given configuration, at the end
+    # the model's configuration attribute will be restored to what it was before calling
+    # this method.
+    def with_configuration(id, _options = {})
+      orig = configuration
+      self.configuration = id
+      yield
+      self.configuration = orig
+    end
+
+    # Returns the current mode/configuration of the top level SoC. If no mode has been specified
+    # yet this will return nil
+    #
+    #   $dut = DUT.new
+    #   $dut.mode             # => default
+    #   $dut.mode.default?    # => true
+    #   $dut.mode.ram_bist?   # => false
+    #   $dut.mode = :ram_bist
+    #   $dut.mode.default?    # => false
+    #   $dut.mode.ram_bist?   # => true
+    def current_mode
+      if @current_mode
+        return _modes[@current_mode] if _modes[@current_mode]
+        fail "The mode #{@current_mode} of #{self.class} has not been defined!"
+      end
+    end
+    alias_method :mode, :current_mode
+
+    # Set the current mode configuration of the current model
+    def current_mode=(id)
+      @current_mode = id.is_a?(ChipMode) ? id.id : id
+    end
+    alias_method :mode=, :current_mode=
+
+    def add_mode(id, options = {})
+      m = ChipMode.new(id, options)
+      m.owner = self
+      yield m if block_given?
+      _add_mode(m)
+      m
+    end
+
+    def has_mode?(id)
+      !!(_modes[id.is_a?(ChipMode) ? id.id : id])
+    end
+
+    # Returns an array containing the IDs of all known modes if no ID is supplied,
+    # otherwise returns an object representing the given mode ID
+    def modes(id = nil, _options = {})
+      id = nil if id.is_a?(Hash)
+      if id
+        _modes[id]
+      else
+        _modes.ids
+      end
+    end
+
+    # Executes the given block of code within the context of the given mode, at the end
+    # the mode will be restored back to what it was on entry
+    def with_mode(id, _options = {})
+      orig = mode
+      self.mode = id
+      yield
+      self.mode = orig
+    end
+
+    # Executes the given block of code for each known chip mode, inside the block
+    # the current mode of the top level block will be set to the given mode.
+    #
+    # At the end of the block the current mode will be restored to whatever it
+    # was before entering the block.
+    def with_each_mode
+      begin
+        orig = current_mode
+      rescue
+        orig = nil
+      end
+      modes.each do |_id, mode|
+        self.current_mode = mode
+        yield mode
+      end
+      self.current_mode = orig
+    end
+    alias_method :each_mode, :with_each_mode
+
+    # Sets the modes array to nil.  Written so modes created in memory can
+    # be erased so modes defined in Ruby files can be loaded
+    def delete_all_modes
+      @_modes = nil
+    end
+    alias_method :del_all_modes, :delete_all_modes
+
+    # Returns all specs found for the model.  if none found it returns an empty array
+    def find_specs
+      specs_found = []
+      # Check for specs the object owns
+      if self.respond_to? :specs
+        object_specs = specs
+        unless object_specs.nil?
+          if object_specs.class == Origen::Specs::Spec
+            specs_found << object_specs
+          else
+            specs_found.concat(object_specs)
+          end
+        end
+      end
+      sub_blocks.each do |_name, sb|
+        next unless sb.respond_to? :specs
+        child_specs = sb.specs
+        unless child_specs.nil?
+          if child_specs.class == Origen::Specs::Spec
+            specs_found << child_specs
+          else
+            specs_found.concat(child_specs)
+          end
+        end
+      end
+      specs_found
+    end
+
+    # Delete all specs and notes for self recursively
+    def delete_all_specs_and_notes(obj = nil)
+      obj = self if obj.nil?
+      obj.delete_all_specs
+      obj.delete_all_notes
+      obj.delete_all_exhibits
+      obj.children.each do |_name, child|
+        next unless child.has_specs?
+        delete_all_specs_and_notes(child)
+      end
+    end
+
+    private
+
+    def _modes
+      @_modes ||= {}
+    end
+
+    def _add_mode(mode)
+      if _modes[mode.id]
+        fail "There is already a mode called #{mode.id}!"
+      else
+        _modes[mode.id] = mode
+      end
+    end
+  end
+  # Legacy API
+  IPBlock = Model
+end