origen_arm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aac2a9ad38cd6455af8072078ce1323050ffa8ccd807a309aa162f7a495a1d04
+  data.tar.gz: 40fcc38125de73c08bccb499ffda8e60815ccb46b44b0e96abe50e4e5f8dc2d5
+SHA512:
+  metadata.gz: d558d399e03bd7da9209cf3872801c3d975424682982bdeb5744649ad06a916bacc2e203c9a816c06b9c3d25c57bb3d34d647f196f9799e07789f037c03fdb4d
+  data.tar.gz: 5271ac914b8d3df3e8e5fd9f0c0a2f9c2fec65166e5c235c66f73187ecb14bf85b6aa17c248f25c5ab8fd34a3c4611c5319eb7e782a2ffa25df08ecb0d74a371

data/config/application.rb

@@ -0,0 +1,103 @@
+require 'origen'
+class OrigenARMApplication < Origen::Application
+
+  # See http://origen-sdk.org/origen/api/Origen/Application/Configuration.html
+  # for a full list of the configuration options available
+
+  # These attributes should never be changed, the duplication here will be resolved in future
+  # by condensing these attributes that do similar things
+  self.name       = "origen_arm"
+  self.namespace  = "OrigenARM"
+  config.name     = "origen_arm"
+  config.initials = "OrigenARM"
+  config.rc_url   = "git@github.com:Origen-SDK/origen_arm.git"
+  config.release_externally = true
+  config.gem_name = "origen_arm"
+
+  # To enable deployment of your documentation to a web server (via the 'origen web'
+  # command) fill in these attributes.
+  config.web_directory = "git@github.com:Origen-SDK/Origen-SDK.github.io.git/arm"
+  config.web_domain = "http://origen-sdk.org/arm"
+
+  # When false Origen will be less strict about checking for some common coding errors,
+  # it is recommended that you leave this to true for better feedback and easier debug.
+  # This will be the default setting in Origen v3.
+  config.strict_errors = true
+
+  # See: http://origen-sdk.org/origen/latest/guides/utilities/lint/
+  config.lint_test = {
+    # Require the lint tests to pass before allowing a release to proceed
+    run_on_tag: true,
+    # Auto correct violations where possible whenever 'origen lint' is run
+    auto_correct: true, 
+    # Limit the testing for large legacy applications
+    #level: :easy,
+    # Run on these directories/files by default
+    #files: ["lib", "config/application.rb"],
+  }
+
+  config.semantically_version = true
+
+  # An example of how to set application specific LSF parameters
+  #config.lsf.project = "msg.te"
+  
+  # An example of how to specify a prefix to add to all generated patterns
+  #config.pattern_prefix = "nvm"
+
+  # An example of how to add header comments to all generated patterns
+  #config.pattern_header do
+  #  cc "This is a pattern created by the example origen application"
+  #end
+
+  # By default all generated output will end up in ./output.
+  # Here you can specify an alternative directory entirely, or make it dynamic such that
+  # the output ends up in a setup specific directory. 
+  #config.output_directory do
+  #  "#{Origen.root}/output/#{$dut.class}"
+  #end
+
+  # Similarly for the reference files, generally you want to setup the reference directory
+  # structure to mirror that of your output directory structure.
+  #config.reference_directory do
+  #  "#{Origen.root}/.ref/#{$dut.class}"
+  #end
+ 
+  # This will automatically deploy your documentation after every tag
+  #def after_release_email(tag, note, type, selector, options)
+  #  command = "origen web compile --remote --api"
+  #  Dir.chdir Origen.root do
+  #    system command
+  #  end
+  #end
+
+  # Ensure that all tests pass before allowing a release to continue
+  #def validate_release
+  #  if !system("origen specs") || !system("origen examples")
+  #    puts "Sorry but you can't release with failing tests, please fix them and try again."
+  #    exit 1
+  #  else
+  #    puts "All tests passing, proceeding with release process!"
+  #  end
+  #end
+
+  # To enabled source-less pattern generation create a class (for example PatternDispatcher)
+  # to generate the pattern. This should return false if the requested pattern has been
+  # dispatched, otherwise Origen will proceed with looking up a pattern source as normal.
+  #def before_pattern_lookup(requested_pattern)
+  #  PatternDispatcher.new.dispatch_or_return(requested_pattern)
+  #end
+
+  # If you use pattern iterators you may come across the case where you request a pattern
+  # like this:
+  #   origen g example_pat_b0.atp
+  #
+  # However it cannot be found by Origen since the pattern name is actually example_pat_bx.atp
+  # In the case where the pattern cannot be found Origen will pass the name to this translator
+  # if it exists, and here you can make any substitutions to help Origen find the file you 
+  # want. In this example any instances of _b\d, where \d means a number, are replaced by
+  # _bx.
+  #config.pattern_name_translator do |name|
+  #  name.gsub(/_b\d/, "_bx")
+  #end
+
+end

data/config/boot.rb

@@ -0,0 +1,24 @@
+# This file is used to boot your plugin when it is running in standalone mode
+# from its own workspace - i.e. when the plugin is being developed.
+#
+# It will not be loaded when the plugin is imported by a 3rd party app - in that
+# case only lib/origen_arm.rb is loaded.
+#
+# Therefore this file can be used to load anything extra that you need to boot
+# the development environment for this app. For example, this is typically used
+# to load some additional test classes to use your plugin APIs so that they can
+# be tested and/or interacted with in the console.
+require "origen_arm"
+
+module OrigenARMDev
+  # Example of how to explicitly require a file
+  # require "origen_arm_dev/my_file"
+    
+  # Load all files in the lib/origen_arm_dev directory.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required first, then
+  # explicitly require it up above and then let this take care of the rest.
+  Dir.glob("#{File.dirname(__FILE__)}/../lib/origen_arm_dev/**/*.rb").sort.each do |file|
+    require file
+  end
+end

data/config/commands.rb

@@ -0,0 +1,79 @@
+# This file should be used to extend the origen with application specific commands
+
+# Map any command aliases here, for example to allow 'origen ex' to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "ex" => "execute",
+}
+
+# The requested command is passed in here as @command, this checks it against
+# the above alias table and should not be removed.
+@command = aliases[@command] || @command
+
+# Now branch to the specific task code
+case @command
+
+# (Working) example of how to create an application specific comment, here to generate
+# a tags file for you application to enable method definition lookup and similar within
+# editors/IDEs
+when "tags"  
+  # Here the logic is just written in-line, alternatively it could be written in a
+  # dedicated file and required here, e.g.
+  #require "origen_arm/commands/my_command"    # Would load file lib/origen_arm/commands/my_command.rb
+  Dir.chdir Origen.root do
+    system("ripper-tags -R")
+  end
+  # You must always exit upon successfully capturing and executing a command to prevent 
+  # control flowing back to Origen
+  exit 0
+
+## Example of how to make a command to run unit tests, this simply invokes RSpec on
+## the spec directory
+#when "specs"
+#  require "rspec"
+#  exit RSpec::Core::Runner.run(['spec'])
+
+## Example of how to make a command to run diff-based tests
+#when "examples", "test"
+#  Origen.load_application
+#  status = 0
+#
+#  # Compiler tests
+#  ARGV = %w(templates/example.txt.erb -t debug -r approved)
+#  load "origen/commands/compile.rb"
+#  # Pattern generator tests
+#  #ARGV = %w(some_pattern -t debug -r approved)
+#  #load "#{Origen.top}/lib/origen/commands/generate.rb"
+#
+#  if Origen.app.stats.changed_files == 0 &&
+#     Origen.app.stats.new_files == 0 &&
+#     Origen.app.stats.changed_patterns == 0 &&
+#     Origen.app.stats.new_patterns == 0
+#
+#    Origen.app.stats.report_pass
+#  else
+#    Origen.app.stats.report_fail
+#    status = 1
+#  end
+#  puts
+#  if @command == "test"
+#    Origen.app.unload_target!
+#    require "rspec"
+#    result = RSpec::Core::Runner.run(['spec'])
+#    status = status == 1 ? 1 : result
+#  end
+#  exit status  # Exit with a 1 on the event of a failure per std unix result codes
+
+# Always leave an else clause to allow control to fall back through to the
+# Origen command handler.
+else
+  # You probably want to also add the your commands to the help shown via
+  # origen -h, you can do this by assigning the required text to @application_commands
+  # before handing control back to Origen.
+  @application_commands = <<-EOT
+ tags         Build a tags file for this app
+  EOT
+# specs        Run the specs (tests), -c will enable coverage
+# examples     Run the examples (tests), -c will enable coverage
+# test         Run both specs and examples, -c will enable coverage
+end 

data/config/version.rb

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

data/lib/origen_arm.rb

@@ -0,0 +1,19 @@
+require 'origen_testers'
+require 'origen'
+require_relative '../config/application.rb'
+module OrigenARM
+  # THIS FILE SHOULD ONLY BE USED TO LOAD RUNTIME DEPENDENCIES
+  # If this plugin has any development dependencies (e.g. dummy DUT or other models that are only used
+  # for testing), then these should be loaded from config/boot.rb
+
+  # Example of how to explicitly require a file
+  # require "origen_arm/my_file"
+
+  # Load all files in the lib/origen_arm directory.
+  # Note that there is no problem from requiring a file twice (Ruby will ignore
+  # the second require), so if you have a file that must be required first, then
+  # explicitly require it up above and then let this take care of the rest.
+  Dir.glob("#{File.dirname(__FILE__)}/origen_arm/**/*.rb").sort.each do |file|
+    require file
+  end
+end

data/lib/origen_arm/cores/base_core/core.rb

@@ -0,0 +1,8 @@
+module OrigenARM
+  module Cores
+    class Base
+      def initialize(options = {})
+      end
+    end
+  end
+end

data/lib/origen_arm/cores/base_core/core_controller.rb

@@ -0,0 +1,8 @@
+module OrigenARM
+  module Cores
+    class BaseController
+      def initialize(options = {})
+      end
+    end
+  end
+end

data/lib/origen_arm/cores/base_core/core_registers.rb

@@ -0,0 +1,8 @@
+module OrigenARM
+  module Cores
+    class Base
+      module Registers
+      end
+    end
+  end
+end

data/lib/origen_arm/cores/cortexm/base_cortexm/cortexm.rb

@@ -0,0 +1,51 @@
+module OrigenARM
+  module Cores
+    module CortexM
+      class Base < OrigenARM::Cores::Base
+        require_relative 'cortexm_registers'
+
+        include Origen::Model
+        include Registers
+
+        attr_reader :enter_debug_mode_delay_cycles
+        attr_reader :exit_debug_mode_delay_cycles
+        attr_reader :write_debug_register_delay
+        attr_reader :read_debug_register_delay
+
+        # Initialize the CortexM base.
+        # @param [Hash] options CortexM Base options.
+        # @option options [True, False] :no_init_common_registers Skip initializing common registers entirely.
+        # @option options [Fixnum] :enter_debug_mode_delay_cycles
+        #   Customize the delay (in cycles) to wait for the device to enter debug mode.
+        # @option options [Fixnum] :exit_debug_mode_delay_cycles
+        #   Customize the delay (in cycles) to wait for the device to exit debug mode.
+        # @note For the most part, enter/exit debug mode delay cycles should be the same,
+        #   so the same override will affect both. For these to be truely different,
+        #   both options must be given.
+        def initialize(options = {})
+          # Initialize any common registers followed by the core's own registers.
+          # Note that the core's #initialize_registers could re-configure or
+          # remove any common registers that aren't actually common to that core.
+          OrigenARM::Cores::CortexM::Base::Registers.instantiate_registers(self, options) unless options[:no_init_common_registers]
+          instantiate_registers(options) if respond_to?(:instantiate_registers)
+
+          @enter_debug_mode_delay_cycles = options[:enter_debug_mode_delay_cycles] || options[:exit_debug_mode_delay_cycles] || 50
+          @exit_debug_mode_delay_cycles  = options[:exit_debug_mode_delay_cycles] || options[:enter_debug_mode_delay_cycles] || 50
+
+          @write_debug_register_delay = options[:write_debug_register_delay] || 1000
+          @read_debug_register_delay  = options[:read_debug_register_delay] || 1000
+
+          super
+        end
+
+        # Returns the location of the <code>Registers</code> module.
+        # @return [Module]
+        # @example Retrieve the register scope of the CM33 core model.
+        #   dut.cm33_core._registers_scope #=> OrigenARM::Cores::CortexM::CM33::Registers
+        def _registers_scope
+          eval("#{self.class}::Registers")
+        end
+      end
+    end
+  end
+end

data/lib/origen_arm/cores/cortexm/base_cortexm/cortexm_controller.rb

@@ -0,0 +1,152 @@
+module OrigenARM
+  module Cores
+    module CortexM
+      class BaseController < OrigenARM::Cores::BaseController
+        include Origen::Controller
+
+        def initialize(options = {})
+          super
+        end
+
+        # Delays for the core to to enter debug mode.
+        # @note The delay (in cycles) can be set by initializing the core
+        #   subblock parameter <code>:enter_debug_mode_delay_cycles</code>.
+        # @note If the <code>DUT</code> provides the same method, that method
+        #   will be used in place of this one.
+        def enter_debug_mode_delay!
+          if dut.respond_to?('enter_debug_mode_delay!'.to_sym)
+            cc 'Using DUT-defined #enter_debug_mode_delay! for core to enter debug mode'
+            dut.enter_debug_mode_delay!
+          else
+            cc "Delaying #{enter_debug_mode_delay_cycles} cycles for core to enter debug mode"
+            tester.cycle(repeat: enter_debug_mode_delay_cycles)
+          end
+        end
+
+        # Delays for the core to to exit debug mode.
+        # @note The delay (in cycles) can be set by initializing the core
+        #   subblock parameter <code>:exit_debug_mode_delay_cycles</code>.
+        # @note If the <code>DUT</code> provides the same method, that method
+        #   will be used in place of this one.
+        def exit_debug_mode_delay!
+          if dut.respond_to?('exit_debug_mode_delay!'.to_sym)
+            cc 'Using DUT-defined #exit_debug_mode_delay! for core to exit debug mode'
+            dut.exit_debug_mode_delay!
+          else
+            cc "Delaying #{exit_debug_mode_delay_cycles} cycles for core to exit debug mode"
+            tester.cycle(repeat: exit_debug_mode_delay_cycles)
+          end
+        end
+
+        # Runs the given block in debug mode, exiting debug mode upon completion.
+        # @param with_core_halted [true, false] Indicates if the core should be halted while executing the given blocck.
+        #   If true, the core will be released upon debug mode exit.
+        # @note This is equivalent to: <br>
+        #   -> <code>enter_debug_mode(halt_core: with_core_halted)</code> <br>
+        #   -> <code>...</code> <br>
+        #   -> <code>exit_debug_mode(release_core: with_core_halted)</code>
+        # @example Perform a write/read-expect operation on <code>dut.core(:reg1)</code>
+        #   dut.core.in_debug_mode do
+        #     dut.core.reg(:reg7).write!(0x7)
+        #     dut.core.reg(:reg7).read!(0x7)
+        #   end
+        def in_debug_mode(with_core_halted: false)
+          enter_debug_mode(halt_core: with_core_halted)
+          yield
+          exit_debug_mode(release_core: with_core_halted)
+        end
+        alias_method :with_debug_mode, :in_debug_mode
+        alias_method :with_debug_enabled, :in_debug_mode
+
+        # Certain registers within the core must be written in certain ways.
+        # Override the <code>reg.read!</code> and <code>reg.write!</code> methods to have Origen handle this.
+        # @note This doesn't protect from the user copying the register to a different namepace,
+        #   nor from using the address directly.
+        # @note This method will use the toplevel's <code>reg.write!</code>.
+        #   This is just wraps the write process for certain registers.
+        # @see Link: <a href='https://origen-sdk.org/origen/guides/pattern/registers/#Basic_Concept'>Registers Docs</a>
+        def write_register(reg, options = {})
+          if reg_wrapped_by_dcrsr?(reg)
+            # This register write requires a few steps:
+            # 1. Write the dcrdr register with the data.
+            #
+            # 2a. Write the dcrsr[:regwnr] bit to 1 (indicate a write)
+            # 2b. Write the regsel bits with the desired register.
+            # (The above two take place in a single transaction)
+            #
+            # Writing the dcrsr will trigger the write to occur. Very important
+            # the write to the dcrdr occurs first.
+            #
+            # This requires a reg_sel lookup.
+            pp("Writing Debug Register: #{reg.name} <- #{reg.data.to_hex}") do
+              reg(:dcrdr).write!(reg.data)
+              reg(:dcrsr).bits(:regwnr).write(1)
+              reg(:dcrsr).bits(:reg_sel).write(reg.address)
+              reg(:dcrsr).write!
+              tester.cycle(repeat: write_debug_register_delay)
+            end
+          else
+            # Nothing special about this registers. Write it as normal.
+            parent.write_register(reg, options)
+          end
+        end
+
+        # Certain registers within the core must be written in certain ways.
+        # Override the <code>reg.read!</code> and <code>reg.write!</code> methods to have Origen handle this.
+        # @note This doesn't protect from the user copying the register to a different namepace,
+        #   nor from using the address directly.
+        # @note This method will use the toplevel's <code>reg.read!</code>.
+        #   This is just wraps the write process for certain registers.
+        # @see Link: <a href='https://origen-sdk.org/origen/guides/pattern/registers/#Basic_Concept'>Registers Docs</a>
+        def read_register(reg, options = {})
+          if reg_wrapped_by_dcrsr?(reg)
+            pp("Reading and Comparing Core Register: DCRDR <- #{reg.name}.data (expecting #{reg.data}") do
+              core_reg_to_dcrdr(reg, options)
+              reg(:dcrdr).read!(reg.data)
+            end
+          else
+            # Nothing special about this registers. Write it as normal.
+            parent.read_register(reg, options)
+          end
+        end
+
+        # Reads the core register and places its contents in the DCRDR, but does
+        # not invoke and tester-level compares.
+        # @note This is a shortcut to a <code>reg.read!</code> call that masks all the bits.
+        # @todo Implement <code>Raise</code> condition.
+        # @raise [OrigenARM::CoreRegisterError] If <code>reg</code> is not a core register.
+        # @note See the implementation of #write_register for additional details on the internals.
+        # @note All core registers are 32-bits. Any contents in the DCRDR will be overwritten.
+        def core_reg_to_dcrdr(reg, options)
+          if reg_wrapped_by_dcrsr?(reg)
+            pp("Copying Core Register to DCRDR: DCRDR <- #{reg.name}.data") do
+              reg(:dcrsr).bits(:regwnr).write(0)
+              reg(:dcrsr).bits(:reg_sel).write(reg.address)
+              reg(:dcrsr).write!
+              tester.cycle(repeat: read_debug_register_delay)
+            end
+          else
+            Origen.app.fail!(
+              message:   'Method #core_reg_to_dcrdr can only be run with the core debug registers. ' \
+                       "Given register #{reg.is_a?(Register) ? reg.name : reg.to_s} is not classified as a core register.",
+              exception: OrigenARM::CoreRegisterError
+            )
+          end
+        end
+
+        # Checks if the register given is either a <code>general_purpose_register</code>, <code>special_purpose_register</code>,
+        # or a <code>floating_point_register</code>. <br> <br> Read and writes to these regsters are wrapped around the
+        # <code>DHRCR</code> and <code>DHRSR</code> registers.
+        # @raise NoRegisterError If <code>reg</code> could not be converted to a register within the selected core.
+        # @note Register type indication is done per regster, when adding registers. This method just checks that field.
+        def reg_wrapped_by_dcrsr?(reg)
+          # If reg isn't an Origen register, convert it to one.
+          r = reg.is_a?(Origen::Registers::Reg) ? reg : self.reg(reg)
+
+          # The register type is a custom field stored in the registers metadata.
+          r.meta[:general_purpose_register] || r.meta[:special_purpose_register] || r.meta[:floating_point_register]
+        end
+      end
+    end
+  end
+end