origen 0.5.7 → 0.5.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7890471b8ec2f67729fe1f77eb91bc06203fd708
-  data.tar.gz: 46e1254090dfd0a60417b29877d4fd8fe6903b45
+  metadata.gz: f23605859c980dd6d2640897a4245aad8906766c
+  data.tar.gz: 2e771418b57f561353455cfff1ae6018124742c5
 SHA512:
-  metadata.gz: 48539a0c1c7d0dd911d39c896a6510ad88cda19aec158c94241032337d3977439574b7c827f653a382dea13c96652c6b0f55f0bb363428bdf8e622c792424962
-  data.tar.gz: 1d3cc10f4d91369a046bed8a86fe77cecaffeff7f8b6c1644d542b146718b0620cecfeea8bd07b8d368b38b497f71586d9546e51744f45479ccbcff0676ab170
+  metadata.gz: 2c4ad2bba1cfbc00dba89d9764f0276d846039286e15378c6cdb11d25c19a25f729057583a6c23c24decbfbd3f75052d8ad5ffa061e0d2d36fb3b11511d57076
+  data.tar.gz: 87b0b8ae625116e81cd673f1e7384d23de2b6be4d5f6195ee11f99f7b3885bed74eb6996e19f09759a32dc159f6a4a832a9f1668098abccae447d5ff83c6f0e5

data/config/version.rb

@@ -1,7 +1,7 @@
 module Origen
   MAJOR = 0
   MINOR = 5
-  BUGFIX = 7
+  BUGFIX = 8
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/helpers/guides.rb

@@ -8,6 +8,7 @@ facebook: origensdk
 twitter: origensdk
 author_url: https://plus.google.com/u/1/b/106463981272125989995/106463981272125989 
 site_name: Origen - The Semiconductor Developer's Kit
+gitter_chat: Origen-SDK/users
 END
   end
 

data/lib/origen.rb

@@ -21,6 +21,7 @@ unless defined? RGen::ORIGENTRANSITION
   require 'origen/logger_methods'
   require 'option_parser/optparse'
   require 'bundler'
+  require 'origen/undefined'
 
   module Origen
     autoload :Features,  'origen/features'
@@ -28,6 +29,7 @@ unless defined? RGen::ORIGENTRANSITION
     autoload :Generator, 'origen/generator'
     autoload :Pins,      'origen/pins'
     autoload :Registers, 'origen/registers'
+    autoload :Ports,     'origen/ports'
     autoload :Users,     'origen/users'
     autoload :FileHandler, 'origen/file_handler'
     autoload :RegressionManager, 'origen/regression_manager'
@@ -49,6 +51,8 @@ unless defined? RGen::ORIGENTRANSITION
     autoload :Encodings, 'origen/encodings'
     autoload :Log,       'origen/log'
     autoload :Chips,     'origen/chips'
+    autoload :Netlist,   'origen/netlist'
+    autoload :Models,    'origen/models'
 
     APP_CONFIG = File.join('config', 'application.rb')
 

data/lib/origen/commands.rb

@@ -218,6 +218,10 @@ when 'generate', 'program', 'compile', 'merge', 'interactive', 'target', 'enviro
   require "origen/commands/#{@command}"
   exit 0 unless @command == 'interactive'
 
+when 'exec'
+  load ARGV.first
+  exit 0
+
 when 'version'
   Origen.app # Load app
   require 'origen/commands/version'
@@ -242,6 +246,7 @@ The core origen commands are:
  program      Generate a test program (short-cut alias: "p")
  interactive  Start an interactive Origen console (short-cut alias: "i")
  compile      Compile a template file or directory (short-cut alias: "c")
+ exec         Execute any Ruby file with access to your app environment
 
  rc           Revision control commands, see -h for details
  save         Save the new or changed files from the last run or a given log file

data/lib/origen/core_ext/numeric.rb

@@ -1,4 +1,8 @@
 class Numeric
+  def undefined?
+    false
+  end
+
   def to_hex
     "0x#{to_s(16).upcase}"
   end

data/lib/origen/core_ext/range.rb

@@ -4,4 +4,13 @@ class Range
     last = self.last
     last..first
   end
+
+  def to_a
+    a = super
+    if a.empty?
+      reverse.to_a.reverse
+    else
+      a
+    end
+  end
 end

data/lib/origen/core_ext/string.rb

@@ -55,7 +55,8 @@ class String
   # Sanitizes the string for conversion to a symbol and returns a lower
   # cased symbol version of the string
   def symbolize
-    gsub(/(\n|\s|\(|\)|\.|\[|\]|-|{|})/, '_').downcase.to_sym
+    @@symbolize ||= {}
+    @@symbolize[self] ||= gsub(/(\n|\s|\(|\)|\.|\[|\]|-|{|})/, '_').downcase.to_sym
   end
 
   # acronyms

data/lib/origen/global_methods.rb

@@ -57,6 +57,10 @@ module Origen
       binding
     end
 
+    def undefined
+      Origen::UndefinedClass.instance
+    end
+
     Pattern = Origen.pattern unless defined?(Pattern)
     Flow = Origen.flow unless defined?(Flow)
     Resources = Origen.resources unless defined?(Resources)

data/lib/origen/model.rb

@@ -19,6 +19,8 @@ module Origen
       include Origen::SubBlocks
       include Origen::Parameters
       include Origen::Specs
+      include Origen::Ports
+      include Origen::Netlist
     end
 
     module ClassMethods
@@ -293,8 +295,34 @@ module Origen
       end
     end
 
+    # Returns true after the model's initialize method has been run
+    def initialized?
+      !!@initialized
+    end
+
+    def clock!
+      clock_prepare
+      clock_apply
+    end
+
+    def clock_prepare
+      sub_blocks.each do |name, block|
+        block.clock_prepare if block.respond_to?(:clock_prepare)
+      end
+    end
+
+    def clock_apply
+      sub_blocks.each do |name, block|
+        block.clock_apply if block.respond_to?(:clock_apply)
+      end
+    end
+
     private
 
+    def initialized
+      @initialized = true
+    end
+
     def _controller=(controller)
       @controller = controller
     end

data/lib/origen/model_initializer.rb

@@ -21,11 +21,15 @@ module Origen
           parent = options.delete(:parent)
           x.parent = parent if parent
         end
+        options.each do |k, v|
+          x.send(:instance_variable_set, "@#{k}", v) if x.respond_to?(k)
+        end
         if x.method(:initialize).arity == 0
           x.send(:initialize, &block)
         else
           x.send(:initialize, *args, &block)
         end
+        x.send(:initialized) if x.respond_to?(:is_an_origen_model?)
         x.register_callback_listener if x.respond_to?(:register_callback_listener)
         # Do this before wrapping, otherwise the respond to method in the controller will
         # be looking for the model to be instantiated when it is not fully done yet

data/lib/origen/models.rb

@@ -0,0 +1,6 @@
+module Origen
+  module Models
+    autoload :ScanRegister,    'origen/models/scan_register'
+    autoload :Mux,    'origen/models/mux'
+  end
+end

data/lib/origen/models/mux.rb

@@ -0,0 +1,26 @@
+module Origen
+  module Models
+    class Mux
+      include Origen::Model
+
+      attr_reader :size
+      attr_reader :select_lines
+
+      def initialize(options = {})
+        @input = []
+        (2**select_lines).times do |i|
+          @input << port("input#{i}".to_sym, size: size)
+        end
+
+        port :select, size: select_lines
+        port :output, size: size
+
+        output.connect_to do |i|
+          unless ports[:select].data.undefined?
+            send("input#{ports[:select].data}")[i].path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen/models/scan_register.rb

@@ -0,0 +1,74 @@
+module Origen
+  module Models
+    class ScanRegister
+      include Origen::Model
+
+      attr_reader :size
+
+      def initialize(options = {})
+        # The shift register
+        reg :sr, 0, size: size, reset: options[:reset] || 0
+        # The update register, this is the value presented to the outside world
+        reg :ur, 0, size: size, reset: options[:reset] || 0
+
+        port :si              # Scan in
+        port :so              # Scan out
+        port :c, size: size   # Capture in
+
+        # Control signals
+        port :se  # Shift enable
+        port :ce  # Capture enable
+        port :ue  # Update enable
+
+        so.connect_to(sr[0])
+      end
+
+      def method_missing(method, *args, &block)
+        if BitCollection.instance_methods.include?(method)
+          ur.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(*args)
+        super(*args) || BitCollection.instance_methods.include?(args.first)
+      end
+
+      def mode
+        if se.data == 1
+          :shift
+        elsif ce.data == 1
+          :capture
+        elsif ue.data == 1
+          :update
+        else
+          undefined
+        end
+      end
+
+      def clock_prepare
+        @mode = mode
+        if @mode == :shift
+          @din = si.data
+        elsif @mode == :capture
+          @din = c.data
+        elsif @mode == :update
+          @din = sr.data
+        end
+      end
+
+      def clock_apply
+        if @mode == :shift
+          sr.shift_right(@din)
+        elsif @mode == :capture
+          sr.write(@din)
+        elsif @mode == :update
+          ur.write(@din)
+        end
+        @din = nil
+        @mode = nil
+      end
+    end
+  end
+end

data/lib/origen/netlist.rb

@@ -0,0 +1,24 @@
+module Origen
+  module Netlist
+    autoload :List,        'origen/netlist/list'
+    autoload :Connectable, 'origen/netlist/connectable'
+
+    def netlist
+      @netlist ||= begin
+        if netlist_top_level == self
+          List.new(self)
+        else
+          netlist_top_level.netlist
+        end
+      end
+    end
+
+    def netlist_top_level
+      @netlist_top_level ||= begin
+        p = self
+        p = p.parent while p.respond_to?(:parent) && p.parent
+        p
+      end
+    end
+  end
+end

data/lib/origen/netlist/connectable.rb

@@ -0,0 +1,18 @@
+module Origen
+  module Netlist
+    module Connectable
+      extend ActiveSupport::Concern
+
+      included do
+        include Origen::Netlist
+      end
+
+      def connect_to(node = nil, options = {}, &block)
+        node, options = nil, node if node.is_a?(Hash)
+        node = node.path if node.respond_to?(:path)
+        netlist.connect(path, node, &block)
+      end
+      alias_method :connect, :connect_to
+    end
+  end
+end

data/lib/origen/netlist/list.rb

@@ -0,0 +1,152 @@
+module Origen
+  module Netlist
+    class List
+      attr_reader :top_level, :table
+
+      alias_method :parent, :top_level
+      alias_method :owner, :top_level
+
+      def initialize(top_level)
+        @top_level = top_level
+        @table = {}
+      end
+
+      # Connect two paths together in the netlist, one can be a numeric
+      # value to represent a logic level connection
+      def connect(a, b = nil, &block)
+        b ||= block
+        align(a, b) do |path, index, target|
+          table[path] ||= {}
+          table[path][index] ||= []
+          table[path][index] << target
+        end
+      end
+
+      def data_bit(path, index, options = {})
+        bits = data_bits(path, index, options)
+        if bits.size > 1
+          fail "Multiple data bit connections found for node #{path}[#{index}]"
+        elsif bits.size == 0
+          return undefined
+        end
+        bits.first
+      end
+
+      def data_bits(path, index, options = {})
+        processed_paths = options[:processed_paths] || []
+        bits = []
+        ['*', index].each do |i|
+          unless processed_paths.include?("#{path}[#{i}]")
+            processed_paths << "#{path}[#{i}]"
+            vals = (table[path] || {})[i] || []
+            # Also consider anything attached directly to the requested path, e.g. a
+            # drive value applied to a port
+            vals << "#{path}[#{i}]" if i != '*' && !options[:sublevel]
+            vals.each do |val|
+              if val.is_a?(Proc)
+                from_proc = true
+                val = val.call(index)
+              else
+                from_proc = false
+              end
+              if val.is_a?(Fixnum)
+                bits << Registers::Bit.new(nil, index, access: :ro, data: (i == '*' && !from_proc) ? val[index] : val)
+              elsif val
+                vp, vi = *to_v(val)
+                bc = eval("top_level.#{vp}[#{vi || index}]")
+                if bc.is_a?(Registers::BitCollection)
+                  bits << bc.bit
+                elsif bc.is_a?(Ports::Section) && bc.drive_value
+                  bits << Registers::Bit.new(nil, index, access: :ro, data: bc.drive_value)
+                else
+                  bits += data_bits(vp, vi || index, processed_paths: processed_paths, sublevel: true) || []
+                end
+              end
+            end
+          end
+        end
+        bits.uniq
+      end
+
+      private
+
+      def align(a, b)
+        a, b = clean(a), clean(b)
+        if a[:size] || b[:size]
+          if a[:size] && b[:size]
+            size = [a[:size], b[:size]].min
+          else
+            size = a[:size] || b[:size]
+          end
+
+          unless a[:numeric] || a[:proc]
+            size.times do |i|
+              index = a[:indexes] ? a[:indexes][i] : i
+              if b[:numeric]
+                target = b[:path][i]
+              elsif b[:proc]
+                target = b[:path]
+              else
+                if b[:indexes]
+                  target = "#{b[:path]}[#{b[:indexes][i]}]"
+                else
+                  target = "#{b[:path]}[#{i}]"
+                end
+              end
+              yield a[:path], index, target
+            end
+          end
+
+          unless b[:numeric] || b[:proc]
+            size.times do |i|
+              index = b[:indexes] ? b[:indexes][i] : i
+              if a[:numeric]
+                target = a[:path][i]
+              elsif a[:proc]
+                target = a[:path]
+              else
+                if a[:indexes]
+                  target = "#{a[:path]}[#{a[:indexes][i]}]"
+                else
+                  target = "#{a[:path]}[#{i}]"
+                end
+              end
+              yield b[:path], index, target
+            end
+          end
+
+        else
+          yield a[:path], '*', b[:path] unless a[:numeric] || a[:proc]
+          yield b[:path], '*', a[:path] unless b[:numeric] || b[:proc]
+        end
+      end
+
+      def clean(path)
+        if path.is_a?(Fixnum)
+          { path: path, numeric: true }
+        elsif path.is_a?(Proc)
+          { path: path, proc: true }
+        else
+          if path =~ /(.*)\[(\d+):?(\d*)\]$/
+            if Regexp.last_match(3).empty?
+              { path: Regexp.last_match(1), size: 1, indexes: [Regexp.last_match(2).to_i] }
+            else
+              a = ((Regexp.last_match(2).to_i)..(Regexp.last_match(3).to_i)).to_a
+              { path: Regexp.last_match(1), size: a.size, indexes: a }
+            end
+          else
+            { path: path }
+          end
+        end
+      end
+
+      def to_v(path)
+        if path =~ /(.*)\[(\d+)\]$/
+          [Regexp.last_match(1), Regexp.last_match(2).to_i]
+        else
+          [path, nil]
+        end
+      end
+    end
+  end
+end