origen 0.27.0 → 0.28.0

data/lib/origen/model/exporter.rb

@@ -0,0 +1,238 @@
+module Origen
+  module Model
+    module Exporter
+      def export(name, options = {})
+        options = {
+          include_pins:       true,
+          include_registers:  true,
+          include_sub_blocks: true,
+          include_timestamp:  true,
+          file_path:          nil
+        }.merge(options)
+        if options[:file_path]
+          file = File.join(options[:file_path], "#{name}.rb")
+        else
+          file = export_path(name)
+        end
+        file += '.rb' unless file =~ /.rb$/
+        file = Pathname.new(file)
+        FileUtils.rm_rf(file.sub_ext('').to_s) if File.exist?(file.sub_ext('').to_s)
+        FileUtils.rm_rf(file.to_s) if File.exist?(file.to_s)
+        FileUtils.mkdir_p(file.dirname)
+        File.open(file, 'w') do |f|
+          export_wrap_with_namespaces(f, options) do |indent|
+            f.puts((' ' * indent) + 'def self.extended(model)')
+            indent += 2
+            if top_level?
+              # Write out packages if any
+              unless Origen.top_level.packages.empty?
+                spaces = ' ' * indent
+                Origen.top_level.packages.each { |p| f.puts "#{spaces}model.add_package :#{p}\n" }
+              end
+            end
+            if options[:include_pins]
+              if top_level?
+                pins.each do |id, pin|
+                  f.puts export_pin(id, pin, indent: indent)
+                end
+                pin_groups.each do |id, pins|
+                  f.puts export_pin_group(id, pins, indent: indent)
+                end
+                power_pins.each do |id, pin|
+                  f.puts export_pin(id, pin, indent: indent, method: :add_power_pin, attributes: [:voltage, :current_limit])
+                end
+                power_pin_groups.each do |id, pins|
+                  f.puts export_pin_group(id, pins, indent: indent, method: :add_power_pin_group)
+                end
+                ground_pins.each do |id, pin|
+                  f.puts export_pin(id, pin, indent: indent, method: :add_ground_pin)
+                end
+                ground_pin_groups.each do |id, pins|
+                  f.puts export_pin_group(id, pins, indent: indent, method: :add_ground_pin_group)
+                end
+                f.puts
+              end
+            end
+            if options[:include_sub_blocks]
+              sub_blocks.each do |name, block|
+                f.puts export_sub_block(name, block, options.merge(indent: indent, file_path: file))
+              end
+              f.puts unless sub_blocks.empty?
+            end
+
+            if options[:include_registers]
+              regs.each do |name, reg|
+                f.puts export_reg(name, reg, indent: indent)
+              end
+            end
+
+            indent -= 2
+            f.puts((' ' * indent) + 'end')
+          end
+        end
+      end
+
+      def import(name, options = {})
+        path = export_path(name)
+        require path
+        extend "#{Origen.app.namespace.underscore.camelcase}::#{name.to_s.camelcase}".constantize
+      end
+
+      private
+
+      def write_pin_packages(pin)
+        ''.tap do |str|
+          unless pin.packages.empty?
+            str << 'packages: { '
+            pin.packages.each do |pin_pkg, pin_pkg_meta|
+              pkg_end_str = (pin_pkg == pin.packages.keys.last) ? ' }' : ', '
+              if pin_pkg_meta.empty?
+                str << "#{pin_pkg}: {}#{pkg_end_str}"
+                next
+              else
+                str << "#{pin_pkg}: { "
+                pin_pkg_meta.each do |attr, attr_val|
+                  str << "#{attr}: "
+                  attr_end_str = (attr == pin_pkg_meta.keys.last) ? ' }' : ', '
+                  case attr_val
+                  when String
+                    str << "'#{attr_val}'#{attr_end_str}"
+                  else
+                    str << "#{attr_val}#{attr_end_str}"
+                  end
+                end
+                str << pkg_end_str
+              end
+            end
+          end
+        end
+      end
+
+      def export_wrap_with_namespaces(file, options = {})
+        file.puts '# This file was generated by Origen, any hand edits will likely get overwritten'
+        if options[:include_timestamp]
+          file.puts "# Created at #{Time.now.strftime('%e %b %Y %H:%M%p')} by #{User.current.name}"
+        end
+        file.puts '# rubocop:disable all'
+        indent = 0
+        export_module_names_from_path(file.path).each do |name|
+          file.puts((' ' * indent) + "module #{name}")
+          indent += 2
+        end
+        yield indent
+        export_module_names_from_path(file.path).each do |name|
+          indent -= 2
+          file.puts((' ' * indent) + 'end')
+        end
+        file.puts '# rubocop:enable all'
+      end
+
+      def export_module_names_from_path(name)
+        name = name.sub("#{export_dir}/", '').sub('.rb', '')
+        name.split(/[\/\\]/).map do |n|
+          if n == ''
+            nil
+          else
+            n.camelcase
+          end
+        end.compact
+      end
+
+      def export_path(name)
+        File.join(export_dir, Origen.app.namespace.to_s.underscore, name.to_s.underscore)
+      end
+
+      def export_dir
+        File.join(Origen.root, 'vendor', 'lib', 'models')
+      end
+
+      def export_pin(id, pin, options = {})
+        indent = ' ' * (options[:indent] || 0)
+        line = indent + "model.#{options[:method] || 'add_pin'} :#{id}"
+        if (r = pin.instance_variable_get('@reset')) != :dont_care
+          line << ", reset: :#{r}"
+        end
+        if (d = pin.direction) != :io
+          line << ", direction: :#{d}"
+        end
+        pkg_meta = write_pin_packages(pin)
+        line << ", #{pkg_meta}" unless pkg_meta == ''
+        Array(options[:attributes]).each do |attr|
+          unless (v = pin.send(attr)).nil?
+            if v.is_a?(Numeric)
+              line << ", #{attr}: #{v}"
+            else
+              line << ", #{attr}: '#{v}'"
+            end
+          end
+        end
+        unless pin.meta.empty?
+          line << ', meta: { '
+          line << pin.meta.map do |k, v|
+            if v.is_a?(Numeric)
+              "#{k}: #{v}"
+            else
+              "#{k}: '#{v}'"
+            end
+          end.join(', ')
+          line << ' }'
+        end
+        line
+      end
+
+      def export_pin_group(id, pins, options = {})
+        indent = ' ' * (options[:indent] || 0)
+        line = indent + "model.#{options[:method] || 'add_pin_group'} :#{id}, "
+        if pins.endian == :little
+          line << pins.reverse_each.map { |p| ":#{p.id}" }.join(', ')
+          line << "\n#{indent}model.pins(:#{id}).endian = :little"
+        else
+          line << pins.map { |p| ":#{p.id}" }.join(', ')
+        end
+        line
+      end
+
+      def export_sub_block(id, block, options = {})
+        indent = ' ' * (options[:indent] || 0)
+        file = File.join(options[:file_path].sub_ext(''), "#{id}.rb")
+        local_file = file.to_s.sub("#{export_dir}/", '')
+        line = indent + "model.sub_block :#{id}, file: '#{local_file}'"
+        unless block.base_address == 0
+          line << ", base_address: #{block.base_address.to_hex}"
+        end
+        block.export(id, options.merge(file_path: options[:file_path].sub_ext('').to_s))
+        line
+      end
+
+      def export_reg(id, reg, options = {})
+        indent = ' ' * (options[:indent] || 0)
+        lines = []
+        unless reg.description.empty?
+          reg.description.each { |l| lines << indent + "# #{l}" }
+        end
+        lines << indent + "model.add_reg :#{id}, #{reg.offset.to_hex}, size: #{reg.size} do |reg|"
+        indent = ' ' * ((options[:indent] || 0) + 2)
+        reg.named_bits.each do |name, bits|
+          unless bits.description.empty?
+            bits.description.each { |l| lines << indent + "# #{l}" }
+          end
+          if bits.size == 1
+            line = indent + "reg.bit #{bits.position}, :#{name}"
+          else
+            line = indent + "reg.bit #{bits.position + bits.size - 1}..#{bits.position}, :#{name}"
+          end
+          unless bits.access == :rw
+            line << ", access: :#{bits.access}"
+          end
+          unless bits.reset_val == 0
+            line << ", reset: #{bits.reset_val.to_hex}"
+          end
+          lines << line
+        end
+        indent = ' ' * (options[:indent] || 0)
+        lines << indent + 'end'
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/origen/parameters.rb

@@ -31,8 +31,8 @@ module Origen
       else
         _parameter_sets[name] = Set.new(top_level: true, owner: self)
         if options[:inherit]
-          _validate_parameter_set_name(options[:inherit])
-          parent = _parameter_sets[options[:inherit]]
+          kontext = _validate_parameter_set_name(options[:inherit])
+          parent = kontext[:obj]._parameter_sets[kontext[:context]]
           _parameter_sets[name].copy_defaults_from(parent)
           _parameter_sets[name].define(parent, &block)
         else
@@ -100,10 +100,31 @@ module Origen
 
     private
 
-    def _validate_parameter_set_name(name)
-      unless _parameter_sets.key?(name)
-        puts "Unknown parameter set :#{name} requested for #{self.class}, these are the valid sets:"
-        _parameter_sets.keys.each { |k| puts "  :#{k}" }
+    def _validate_parameter_set_name(expr)
+      # Check if the user specified to inherit from another object
+      # or just passed in a param context
+      param_context = {}.tap do |context_hash|
+        case expr
+        when Symbol
+          # user specified a local context
+          context_hash[:obj] = self
+          context_hash[:context] = expr
+        when String
+          # user specified a DUT path
+          path = expr.split('.')[0..-2].join('.')
+          kontext = expr.split('.')[-1].to_sym
+          context_hash[:obj] = eval(path)
+          context_hash[:context] = kontext
+        else
+          Origen.log.error('Parameter context must be a Symbol (local to self) or a String (reference to another object)!')
+          fail
+        end
+      end
+      if param_context[:obj]._parameter_sets.key?(param_context[:context])
+        return param_context
+      else
+        puts "Unknown parameter set :#{param_context[:context]} requested for #{param_context[:obj].class}, these are the valid sets:"
+        param_context[:obj]._parameter_sets.keys.each { |k| puts "  :#{k}" }
         puts ''
         fail 'Unknown parameter set!'
       end

data/lib/origen/pins.rb

@@ -732,6 +732,7 @@ If you meant to define the pin then use the add_pin method instead.
       }.merge(options)
       pins(id, options, &block)
     end
+    alias_method :power_pin, :power_pins
 
     # Equivalent to the pins method but considers ground pins rather than regular pins
     def ground_pins(id = nil, options = {}, &block)
@@ -741,6 +742,7 @@ If you meant to define the pin then use the add_pin method instead.
       }.merge(options)
       pins(id, options, &block)
     end
+    alias_method :ground_pin, :ground_pins
 
     # Equivalent to the pins method but considers other pins rather than regular pins
     def other_pins(id = nil, options = {}, &block)
@@ -750,6 +752,7 @@ If you meant to define the pin then use the add_pin method instead.
       }.merge(options)
       pins(id, options, &block)
     end
+    alias_method :other_pin, :other_pins
 
     # Equivalent to the pins method but considers virtual pins rather than regular pins
     def virtual_pins(id = nil, options = {}, &block)
@@ -759,6 +762,7 @@ If you meant to define the pin then use the add_pin method instead.
       }.merge(options)
       pins(id, options, &block)
     end
+    alias_method :virtual_pin, :virtual_pins
 
     def delete_all_pins
       Origen.pin_bank.send :empty!

data/lib/origen/pins/pin.rb

@@ -9,7 +9,7 @@ module Origen
 
       # Any attributes listed here will be looked up for the current package context
       # before falling back to a default
-      PACKAGE_SCOPED_ATTRIBUTES = [:location, :dib_assignment]
+      PACKAGE_SCOPED_ATTRIBUTES = [:location, :dib_assignment, :dib_meta]
 
       # Pin Types
       TYPES = [:analog, :digital]
@@ -74,6 +74,7 @@ module Origen
         @value = 0
         @clock = nil
         @meta = options[:meta] || {}
+        @dib_meta = options[:dib_meta] || {}
         on_init(owner, options)
         # Assign the initial state from the method so that any inversion is picked up...
         send(@reset)
@@ -421,6 +422,18 @@ module Origen
       alias_method :add_dib_info, :add_dib_assignment
       alias_method :add_channel, :add_dib_assignment
 
+      def add_dib_meta(pkg, options)
+        unless Origen.top_level.packages.include? pkg
+          Origen.log.error("Cannot add DIB metadata for package '#{pkg}', that package has not been added yet!")
+          fail
+        end
+        options.each do |attr, attr_value|
+          packages[pkg][:dib_meta] ||= {}
+          packages[pkg][:dib_meta][attr] = attr_value
+          add_alias attr_value.to_s.symbolize, package: pkg, mode: :all, configuration: :all
+        end
+      end
+
       # Returns the number of test sites enabled for the pin
       def sites
         dib_assignment.size
@@ -978,6 +991,18 @@ module Origen
         end
       end
 
+      def method_missing(m, *args, &block)
+        if meta.include? m
+          meta[m]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        meta[m] || super
+      end
+
       private
 
       def primary_group=(group)

data/lib/origen/power_domains/power_domain.rb

@@ -1,7 +1,9 @@
+require 'origen/specs'
 module Origen
   module PowerDomains
     class PowerDomain
-      attr_accessor :id, :description, :unit_voltage_range, :nominal_voltage, :setpoint
+      include Origen::Specs
+      attr_accessor :id, :description, :unit_voltage_range, :nominal_voltage, :setpoint, :maximum_voltage_rating, :min, :max
 
       # Generic Power Domain Name
       # This is the power supply that can be blocked off to multiple power supplies
@@ -36,12 +38,31 @@ module Origen
         (block.arity < 1 ? (instance_eval(&block)) : block.call(self)) if block_given?
         @unit_voltage_range = :fixed if @unit_voltage_range.nil?
         fail unless attrs_ok?
+        create_dut_spec unless @min.nil? || @max.nil?
       end
 
       def name
         @id
       end
 
+      # Create DUT specs for the power supply
+      def create_dut_spec
+        if Origen.top_level.specs.nil?
+          set_specs
+        elsif Origen.top_level.specs.include? name
+          Origen.log.error("Cannot create power domain spec '#{name}', it already exists!")
+          fail
+        else
+          set_specs
+        end
+      end
+
+      # Maximum Voltage Rating
+      def maximum_voltage_rating
+        @maximum_voltage_rating
+      end
+      alias_method :mvr, :maximum_voltage_rating
+
       # Sets setpoint equal to nominal_voltage
       def setpoint_to_nominal
         @setpoint = @nominal_voltage
@@ -112,7 +133,8 @@ module Origen
       alias_method :curr_value, :setpoint
       alias_method :value, :setpoint
 
-      # Acceptable voltage range
+      # Power domain can allow either a variable
+      # or fixed unit voltage range (Range or :fixed)
       def unit_voltage_range
         @unit_voltage_range
       end
@@ -129,11 +151,14 @@ module Origen
       # Checks if the setpoint is valid
       # This will need rework once the class has spec limits added
       def setpoint_ok?(val = nil)
-        return true if unit_voltage_range == :fixed
-        if val.nil?
-          unit_voltage_range.include?(setpoint) ? true : false
+        return true if maximum_voltage_rating.nil?
+        compare_val = val.nil? ? setpoint : val
+        if compare_val.nil?
+          false
+        elsif compare_val <= maximum_voltage_rating
+          true
         else
-          unit_voltage_range.include?(val) ? true : false
+          false
         end
       end
       alias_method :value_ok?, :setpoint_ok?
@@ -164,6 +189,16 @@ module Origen
 
       private
 
+      def set_specs
+        Origen.top_level.spec name, :dc do |s|
+          s.description = "#{name.to_s.upcase} Power Domain"
+          s.min = min
+          s.typ = nominal_voltage
+          s.max = max
+          s.unit = 'V'
+        end
+      end
+
       def attrs_ok?
         return_value = true
         unless description.is_a? String
@@ -188,15 +223,20 @@ module Origen
         elsif unit_voltage_range == :fixed
           true
         elsif unit_voltage_range.nil?
-          Origen.log.error("PPEKit: Missing voltage range for power domain '#{name}'!")
+          Origen.log.error("PPEKit: Missing unit voltage range for power domain '#{name}'!")
           false
         elsif unit_voltage_range.is_a? Range
-          if unit_voltage_range.include?(nominal_voltage)
-            true
-          else
-            Origen.log.error("PPEKit: Nominal voltage #{nominal_voltage} is not inbetween the voltage range #{unit_voltage_range} for power domain '#{name}'!")
+          unless unit_voltage_range.include?(nominal_voltage)
+            Origen.log.error("PPEKit: Nominal voltage #{nominal_voltage} is not inbetween the unit voltage range #{unit_voltage_range} for power domain '#{name}'!")
             false
           end
+          unless maximum_voltage_rating.nil?
+            unless unit_voltage_range.last <= maximum_voltage_rating
+              Origen.log.error('PPEKit: Unit voltage range exceeds the maximum voltage range!')
+              fail
+            end
+          end
+          true
         else
           Origen.log.error("Power domain attribute 'unit_voltage_range' must be a Range or set to the value of :fixed!")
           return_value = false