origen 0.5.7 → 0.5.8

data/lib/origen/pins.rb

@@ -170,7 +170,6 @@ module Origen
   # about dealing with a single pin vs. a collection.
   module Pins
     autoload :Pin,           'origen/pins/pin'
-    autoload :Port,          'origen/pins/port'
     autoload :PinCollection, 'origen/pins/pin_collection'
     autoload :PinBank,       'origen/pins/pin_bank'
     autoload :PinCommon,     'origen/pins/pin_common'
@@ -313,11 +312,6 @@ module Origen
       Origen.app.pin_pattern_exclude << options unless options.empty?
     end
 
-    # API v2, deprecated
-    def add_port(id, options = {})
-      add_pins(id, options)
-    end
-
     def add_pin_alias(new_name, original_name, options = {})
       if pin_groups.include?(original_name) # this is a pin group
         if options[:pin] # alias single pin from a pin group
@@ -331,7 +325,6 @@ module Origen
     end
     alias_method :pin_alias, :add_pin_alias
     alias_method :alias_pin, :add_pin_alias
-    alias_method :add_port_alias, :add_pin_alias
 
     def add_pin_group_alias(new_name, original_name, options = {})
       group = Origen.pin_bank.find_or_create_pin_group(new_name, self, options)
@@ -592,8 +585,6 @@ If you meant to define the pin then use the add_pin method instead.
       end
     end
     alias_method :pin, :pins
-    alias_method :port, :pins
-    alias_method :ports, :pins
 
     # Equivalent to the pins method but considers power pins rather than regular pins
     def power_pins(id = nil, options = {}, &block)
@@ -630,67 +621,5 @@ If you meant to define the pin then use the add_pin method instead.
         fail "Error: the object #{id} you tried to delete is not a pin or pingroup"
       end
     end
-
-    # @api private
-    #
-    # If the pin is a port it will select the target pin from it based on the options
-    #
-    # API v2, deprecated
-    def resolve_pin(obj, options)
-      if obj.is_a?(Port)
-        pins = options[:pin] || options[:pins]
-        if pins
-          pins = clean_pin_arg(pins)
-          if pins.size == 1
-            obj[pins.first]
-          else
-            port = Port.new("subset_of_#{obj.id}", obj.owner, add_pins: false, size: pins.size)
-            pins.each do |pin|
-              port.add_pin_object(obj[pin])
-            end
-            port
-          end
-        else
-          obj
-        end
-      else
-        obj
-      end
-    end
-
-    # @api private
-    #
-    # Returns an array of ids, regardless if the input is a single number, an array,
-    # a range, or an array contaning a range
-    #
-    # API v2, deprecated
-    def clean_pin_arg(pin)
-      pin = [pin].flatten
-      pin.map { |obj| range_to_array(obj) }.flatten.sort
-    end
-
-    # @api private
-    #
-    # API v2, deprecated
-    def range_to_array(range)
-      if range.is_a?(Range)
-        a = range.first
-        b = range.last
-        if a > b
-          (b..a).to_a
-        else
-          (a..b).to_a
-        end
-      else
-        range
-      end
-    end
-
-    # API v2, deprecated
-    # @api private
-    def add_pin_object(pin)
-      @pins ||= {}
-      @pins[@pins.size] = pin
-    end
   end
 end

data/lib/origen/pins/pin.rb

@@ -22,8 +22,6 @@ module Origen
       attr_accessor :repeat_previous
       attr_reader :owner
       attr_reader :size
-      # If the pin belongs to a port then this will return the port object
-      attr_accessor :port
       # Returns a hash containing the aliases associated with the given pin
       attr_reader :aliases
       # Returns a hash containing the functions associated with the given pin
@@ -273,7 +271,6 @@ module Origen
           group.include?(self)
         end
       end
-      alias_method :ports, :groups
       alias_method :pin_groups, :groups
 
       def invalidate_group_cache
@@ -453,18 +450,17 @@ module Origen
         end
       end
 
-      # Returns true if the pin belongs to a port.
+      # Returns true if the pin belongs to a pin group.
       #
-      #   add_port :jtag, :size => 6
+      #   add_pins :jtag, size: 6
       #   add_pin  :done
-      #   add_pin_alias :fail, :jtag, :pin => 4
+      #   add_pin_alias :fail, :jtag, pin: 4
       #
-      #   pin(:done).belongs_to_a_port?  # => false
-      #   pin(:fail).belongs_to_a_port?  # => true
-      def belongs_to_a_port?
+      #   pin(:done).belongs_to_a_pin_group?  # => false
+      #   pin(:fail).belongs_to_a_pin_group?  # => true
+      def belongs_to_a_pin_group?
         !groups.empty?
       end
-      alias_method :belongs_to_a_pin_group?, :belongs_to_a_port?
 
       def value
         @value

data/lib/origen/pins/pin_collection.rb

@@ -402,7 +402,7 @@ module Origen
         all?(&:repeat_previous?)
       end
 
-      # Returns true if the (data) from the port is marked to be captured
+      # Returns true if the (data) from the pin collection is marked to be captured
       def to_be_captured?
         all?(&:to_be_captured?)
       end

data/lib/origen/ports.rb

@@ -0,0 +1,66 @@
+module Origen
+  module Ports
+    autoload :Port,     'origen/ports/port'
+    autoload :Section,  'origen/ports/section'
+    autoload :BitCollection,  'origen/ports/bit_collection'
+    autoload :PortCollection,  'origen/ports/port_collection'
+
+    def add_port(name, options = {})
+      p = Port.new(self, name, options)
+      if block_given?
+        p.send(:defining) do
+          yield p
+        end
+      end
+      _ports.add(name.to_s.symbolize, p)
+      p
+    end
+
+    def port(*args, &block)
+      if block_given?
+        add_port(*args, &block)
+      else
+        if args.first
+          if has_port?(args.first)
+            _ports[args.first.to_s.symbolize]
+          else
+            if initialized?
+              puts "Model #{self.class} does not have a port named #{args.first}, the available ports are:"
+              puts _ports.keys
+              puts
+              fail 'Missing port error'
+            else
+              # Assume this is a pin definition while the model is still initializing
+              add_port(*args)
+            end
+          end
+        else
+          _ports
+        end
+      end
+    end
+    alias_method :ports, :port
+
+    def has_port?(name)
+      _ports.key?(name.to_s.symbolize)
+    end
+
+    def method_missing(method, *args, &block)
+      if _ports.key?(method.to_s.symbolize)
+        _ports[method.to_s.symbolize]
+      else
+        super
+      end
+    end
+
+    def respond_to?(sym)
+      has_port?(sym) || super(sym)
+    end
+
+    private
+
+    def _ports
+      @_ports ||= PortCollection.new
+    end
+  end
+end

data/lib/origen/ports/bit_collection.rb

@@ -0,0 +1,6 @@
+module Origen
+  module Ports
+    class BitCollection < Registers::BitCollection
+    end
+  end
+end

data/lib/origen/ports/port.rb

@@ -0,0 +1,129 @@
+module Origen
+  module Ports
+    class Port
+      include Netlist::Connectable
+
+      attr_reader :size
+      attr_reader :parent
+      attr_reader :id
+      attr_reader :type
+
+      alias_method :name, :id
+      alias_method :owner, :parent
+
+      def initialize(parent, id, options = {})
+        @size = options[:size] || 1
+        @parent = parent
+        @id = id
+        @type = options[:type]
+        @bit_names = {}.with_indifferent_access
+      end
+
+      def inspect
+        "<#{self.class}:#{object_id} id:#{id} path:#{path}>"
+      end
+
+      def describe(options = {})
+        desc = ['********************']
+        desc << "Port id:   #{id}"
+        desc << "Port path: #{path}"
+        desc << ''
+        desc << 'Connections'
+        desc << '-----------'
+        desc << ''
+        table = netlist.table
+        ((size - 1)..0).to_a.each do |i|
+          if table[path]
+            c = [table[path]['*'], table[path][i]].flatten.compact.map { |n| n.is_a?(Proc) ? 'Proc' : n }
+            desc << "#{i} - #{c.shift}"
+            c.each do |n|
+              desc << "     - #{n}"
+            end
+          else
+            desc << "#{i} - none"
+          end
+        end
+        desc << ''
+
+        if options[:return]
+          desc
+        else
+          puts desc.join("\n")
+        end
+      end
+
+      def path
+        if parent.path.empty?
+          id.to_s
+        else
+          "#{parent.path}.#{id}"
+        end
+      end
+
+      def bits(index, name, options = {})
+        if @defining
+          @bit_names[name] = index
+        else
+          fail 'Cannot add additional port bits once the port definition is complete'
+        end
+      end
+
+      def drive(value = nil, options = {})
+        value, options = nil, value if value.is_a?(Hash)
+        if options[:index]
+          if options[:index].is_a?(Fixnum)
+            drive_values[options[:index]] = value ? value[0] : nil
+          else
+            options[:index].to_a.each do |i|
+              drive_values[i] = value ? value[i] : nil
+            end
+          end
+        else
+          size.times do |i|
+            drive_values[i] = value ? value[i] : nil
+          end
+        end
+        @drive_value = value
+      end
+
+      def drive_values
+        @drive_values ||= Array.new(size)
+      end
+
+      def to_section
+        Section.new(self, (size - 1)..0)
+      end
+
+      def method_missing(method, *args, &block)
+        if @bit_names.key?(method)
+          Section.new(self, @bit_names[method])
+        elsif BitCollection.instance_methods.include?(method)
+          to_bc.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(*args)
+        @bit_names.key?(args.first) || super(*args) ||
+          BitCollection.instance_methods.include?(args.first)
+      end
+
+      def [](val)
+        Section.new(self, val)
+      end
+
+      def to_bc
+        to_section.to_bc
+      end
+
+      private
+
+      def defining
+        @defining = true
+        yield
+        @defining = false
+      end
+    end
+  end
+end

data/lib/origen/ports/port_collection.rb

@@ -0,0 +1,19 @@
+module Origen
+  module Ports
+    class PortCollection < ::Hash
+      def add(name, port)
+        self[name] = port
+        by_type[port.type] ||= []
+        by_type[port.type] << port
+      end
+
+      def by_type
+        @by_type ||= {}.with_indifferent_access
+      end
+
+      def inspect
+        map { |k, _v| k }.inspect
+      end
+    end
+  end
+end

data/lib/origen/ports/section.rb

@@ -0,0 +1,116 @@
+module Origen
+  module Ports
+    class Section
+      include Netlist::Connectable
+
+      attr_reader :port
+      attr_reader :index
+
+      def initialize(port, index)
+        @port = port
+        @index = index
+      end
+
+      def size
+        size_of(index)
+      end
+
+      def path
+        if index.is_a?(Range)
+          port.path + "[#{index.first}:#{index.last}]"
+        else
+          port.path + "[#{index}]"
+        end
+      end
+
+      def parent
+        port.parent
+      end
+      alias_method :owner, :parent
+
+      def id
+        port.id
+      end
+
+      def drive(value = nil)
+        port.drive(value, index: index)
+      end
+
+      def drive_value
+        if size == 1
+          port.drive_values[index]
+        else
+          fail 'drive_value is only supported for a single bit port section'
+        end
+      end
+
+      def [](index)
+        Section.new(port, align_to_port(index))
+      end
+
+      def respond_to?(*args)
+        super(*args) || BitCollection.instance_methods.include?(args.first)
+      end
+
+      def method_missing(method, *args, &block)
+        if BitCollection.instance_methods.include?(method)
+          to_bc.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def to_bc
+        b = BitCollection.new(port, port.id)
+        indexes = index.respond_to?(:to_a) ? index.to_a : [index]
+        indexes.reverse_each do |i|
+          b << netlist.data_bit(port.path, i)
+        end
+        b
+      end
+
+      private
+
+      def size_of(index)
+        if index.is_a?(Range)
+          (index.first - index.last).abs + 1
+        else
+          1
+        end
+      end
+
+      def align_to_port(val)
+        if val.is_a?(Range)
+          nlsb = lsb + val.last
+          nmsb = nlsb + size_of(val) - 1
+          out_of_range(val) if nmsb > msb
+          i = nmsb..nlsb
+        else
+          i = lsb + val
+          out_of_range(val) if i > msb
+        end
+        i
+      end
+
+      def out_of_range(val)
+        fail "Requested section index (#{val}) is out of range for a port section of size #{size}"
+      end
+
+      def msb
+        if index.is_a?(Range)
+          index.first
+        else
+          index
+        end
+      end
+
+      def lsb
+        if index.is_a?(Range)
+          index.last
+        else
+          index
+        end
+      end
+    end
+  end
+end