origen_arm_debug 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 609583b64578afdec4453eaec6425e0eb3ea447c
+  data.tar.gz: fcb99fc0d5ebaf867853fb59055b0a9ee7fc519d
+SHA512:
+  metadata.gz: 2c0c1690d203d8ef3443927bfce7602e1cd6317c736200aa5dc263dd185611a63e97f9f5e4f1bdd0e0eb1690336b7eb93aa9ecf3621d5db372c9bd0c1fb32b9b
+  data.tar.gz: a25d97c6b5791a6418df1954c599b635cf93035cf2a0de695b9b4be8357fc42d66ac993ed53bad71f750c52c7dc3d3bfcc7175927d4fcbe00bc62a9c74a14c9a

data/config/application.rb

@@ -0,0 +1,59 @@
+class OrigenARMDebugApplication < Origen::Application
+
+  # This information is used in headers and email templates, set it specific
+  # to your application
+  config.name     = "Origen ARM Debug"
+  config.initials = "OrigenARMDebug"
+
+  self.name = "origen_arm_debug"
+  self.namespace = "OrigenARMDebug"
+  config.rc_url = "git@github.com:Origen-SDK/origen_arm_debug.git"
+  config.release_externally = true
+
+  # 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_debug"
+  config.web_domain = "http://origen-sdk.org/arm_debug"
+  
+  config.semantically_version = true
+
+  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"], 
+  } 
+  
+  # Ensure that all tests pass before allowing a release to continue 
+  def validate_release 
+    if !system("origen examples") #|| !system("origen specs") 
+      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 
+  
+  # Run code coverage when deploying the web site 
+  def before_deploy_site 
+    Dir.chdir Origen.root do 
+      system "origen examples -c" 
+      dir = "#{Origen.root}/web/output/coverage"        
+      FileUtils.remove_dir(dir, true) if File.exists?(dir)  
+      system "mv #{Origen.root}/coverage #{dir}" 
+    end 
+  end 
+ 
+  # Deploy the website automatically after a production 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 
+
+end

data/config/commands.rb

@@ -0,0 +1,51 @@
+# This file should be used to extend the origen command line tool with tasks 
+# specific to your application.
+#
+# Also see the official docs on adding commands:
+#   http://origen-sdk.org/origen/latest/guides/custom/commands/
+
+# Map any command aliases here, for example to allow origen -x to refer to a 
+# command called execute you would add a reference as shown below: 
+aliases ={
+#  "-x" => "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
+
+when "examples"  
+  Origen.load_application
+  status = 0
+  
+  # Pattern generator tests
+  ARGV = %w(read_write_reg -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
+  exit status
+
+# Always leave an else clause to allow control to fall back through to the
+# Origen command handler.
+# You probably want to also add the command details to the help shown via
+# origen -h, you can do this be assigning the required text to @application_commands
+# before handing control back to Origen. Un-comment the example below to get started.
+else
+  @application_commands = <<-EOT
+ examples     Run the examples (tests), -c will enable coverage
+  EOT
+
+end 

data/config/development.rb

@@ -0,0 +1,17 @@
+# This file is similar to environment.rb and will be loaded
+# automatically at the start of each invocation of Origen.
+#
+# However the major difference is that it will not be loaded
+# if the application is imported by a 3rd party app - in that
+# case only environment.rb is loaded.
+#
+# Therefore this file should be used to load anything you need
+# to setup a development environment for this app, normally
+# this would be used to define some dummy classes to instantiate
+# your objects so that they can be tested and/or interacted with
+# in the console.
+module OrigenARMDebug
+  autoload :DUT, "origen_arm_debug/dut"
+  autoload :JTAG_DUT, "origen_arm_debug/dut_jtag"
+  autoload :SWD_DUT, "origen_arm_debug/dut_swd"
+end

data/config/environment.rb

@@ -0,0 +1,3 @@
+require "origen_arm_debug"
+
+

data/config/users.rb

@@ -0,0 +1,19 @@
+# This file defines the users associated with your project, it is basically the 
+# mailing list for release notes.
+#
+# You can split your users into "admin" and "user" groups, the main difference 
+# between the two is that admin users will get all tag emails, users will get
+# emails on external/official releases only.
+#
+# Users are also prohibited from running the "origen tag" task, but this is 
+# really just to prevent a casual user from executing it inadvertently and is
+# not intended to be a serious security gate.
+module Origen
+  module Users
+    def users
+      @users ||= [
+        
+      ]
+    end
+  end
+end

data/config/version.rb

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

data/lib/origen_arm_debug.rb

@@ -0,0 +1,16 @@
+require 'origen'
+require_relative '../config/application.rb'
+require 'origen_jtag'
+require 'origen_swd'
+
+# Include this module to add a ARM Debug driver to your class
+module OrigenARMDebug
+  autoload :Driver, 'origen_arm_debug/driver'
+  autoload :SWJ_DP, 'origen_arm_debug/swj_dp'
+  autoload :MemAP,  'origen_arm_debug/mem_ap'
+
+  # Returns an instance of the OrigenARMDebug::Driver
+  def arm_debug
+    @arm_debug ||= Driver.new(self)
+  end
+end

data/lib/origen_arm_debug/abs_if_jtag.rb

@@ -0,0 +1,255 @@
+module OrigenARMDebug
+  class ABSIF_JTAG
+    JTAGC_ARM_ABORT  = 0b1000
+    JTAGC_ARM_DPACC  = 0b1010
+    JTAGC_ARM_APACC  = 0b1011
+    JTAGC_ARM_IDCODE = 0b1110
+    JTAGC_ARM_BYPASS = 0b1111
+
+    attr_reader :owner
+    attr_accessor :write_ap_dly
+    attr_accessor :acc_access_dly
+
+    def initialize(owner, options = {})
+      @owner = owner
+
+      @write_ap_dly = 8
+      @acc_access_dly = 7
+
+      @current_apaddr = 0x00000000
+    end
+
+    #-------------------------------------
+    #  Read tasks - high level
+    #-------------------------------------
+    def R_dp(name, rdata, options = {})
+      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
+      read_dp(name, rdata, options)
+    end
+
+    def RE_dp(name, edata, options = {})
+      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
+      actual = edata
+      R_dp(name, actual, options)
+
+      cc "ABS-IF: RE-DP: #{name} = 0x#{actual.to_s(16).rjust(8, '0')}, "\
+                   "expected = 0x#{edata.to_s(16).rjust(8, '0')}, "\
+                   "mask = 0x#{options[:mask].to_s(16).rjust(8, '0')}"
+    end
+
+    def R_ap(addr, rdata, options = {})
+      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
+      read_ap(addr, rdata, options)
+    end
+
+    def RE_ap(addr, edata, options = {})
+      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
+      actual = edata
+      R_ap(addr, actual, options)
+
+      cc "ABS-IF: RE-AP: addr = 0x#{addr.to_s(16).rjust(8, '0')}, "\
+                  "actual = 0x#{actual.to_s(16).rjust(8, '0')}, "\
+                  "expected = 0x#{edata.to_s(16).rjust(8, '0')}, "\
+                  "mask = 0x#{options[:mask].to_s(16).rjust(8, '0')}"
+    end
+
+    def WAIT_RE_ap(addr, edata, options = {})
+      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
+      actual = edata
+      R_ap(addr, actual, options)
+
+      cc "ABS-IF: WAIT_RE-AP: addr = 0x#{addr.to_s(16).rjust(8, '0')}, "\
+                             "actual = 0x#{actual.to_s(16).rjust(8, '0')}, "\
+                       "expected = 0x#{edata.to_s(16).rjust(8, '0')}, "\
+                       "mask = 0x#{options[:mask].to_s(16).rjust(8, '0')}"
+    end
+
+    #-------------------------------------
+    #  Write tasks - high level
+    #-------------------------------------
+    def W_dp(name, wdata, options = {})
+      options = { w_attempts: 1 }.merge(options)
+      write_dp(name, wdata, options)
+    end
+
+    def WR_dp(name, wdata, options = {})
+      options = { edata: 0x00000000, mask: 0xffffffff, w_attempts: 1, r_attempts: 1 }.merge(options)
+      actual = options[:edata] & options[:mask]
+
+      W_dp(name, wdata, options)
+      R_dp(name, actual, options)
+
+      cc "ABS-IF: WR-DP: #{name} write = 0x#{wdata.to_s(16).rjust(8, '0')}, "\
+                          "read = 0x#{actual.to_s(16).rjust(8, '0')}, "\
+                          "expected = 0x#{options[:edata].to_s(16).rjust(8, '0')}, "\
+                          "mask = 0x#{options[:mask].to_s(16).rjust(8, '0')}"
+    end
+
+    def W_ap(addr, wdata, options = {})
+      options = { w_attempts: 1 }.merge(options)
+      write_ap(addr, wdata, options)
+    end
+
+    def WR_ap(addr, wdata, options = {})
+      options = { edata: 0x00000000, mask: 0xffffffff, w_attempts: 1, r_attempts: 1 }.merge(options)
+      actual = wdata & options[:mask]
+
+      W_ap(addr, wdata, options)
+      R_ap(addr, actual, options)
+
+      cc "ABS-IF: WR-AP:  addr = 0x#{addr.to_s(16).rjust(8, '0')}, "\
+                   "write = 0x#{wdata.to_s(16).rjust(8, '0')}, "\
+                   "read = 0x#{actual.to_s(16).rjust(8, '0')}, "\
+                   "expected = 0x#{options[:edata].to_s(16).rjust(8, '0')}, "\
+                   "mask = 0x#{options[:mask].to_s(16).rjust(8, '0')}"
+    end
+
+    private
+
+    #-------------------------------------
+    #  Implementation of virtual functions
+    #-------------------------------------
+    def read_dp(name, rdata, options = {})
+      options = { r_attempts: 1 }.merge(options)
+
+      set_ir(name) if name == 'IDCODE'
+      case name
+        when 'ABORT' then     puts "#{name} JTAG-DP register is write-only"
+        when 'CTRL/STAT' then dpacc_access(name, 1, random, rdata, options)
+        when 'SELECT' then    dpacc_access(name, 1, random, rdata, options)
+        when 'RDBUFF' then    dpacc_access(name, 1, random, rdata, options)
+        when 'IDCODE' then    owner.owner.jtag.write_dr(random, size: 32)          # need to make parameterized!!!
+        else
+          puts "Unknown JTAG-DP register name #{name}"
+      end
+      if name != 'IDCODE' && name != 'RDBUFF'
+        read_dp('RDBUFF', rdata, options)
+      end
+      cc "ABS-IF: R-DP: #{name}=0x" + rdata.to_s(16).rjust(8, '0')
+    end
+
+    def write_dp(name, wdata, options = {})
+      options = { w_attempts: 1 }.merge(options)
+
+      if name == 'ABORT' && wdata != 0x00000001
+        puts "#{name} register must only ever be written with the value 0x00000001"
+      end
+      case name
+        when 'ABORT' then     dpacc_access(name, 0, wdata, random, options)
+        when 'CTRL/STAT' then dpacc_access(name, 0, wdata, random, options)
+        when 'SELECT' then    dpacc_access(name, 0, wdata, random, options)
+        when 'RDBUFF' then    puts "#{name} JTAG-DP register is read-only"
+        when 'IDCODE' then    puts "#{name} JTAG-DP register is read-only"
+        else;             puts "Unknown JTAG-DP register name #{name}"
+      end
+      cc "ABS-IF: W-DP: #{name} = 0x#{wdata.to_s(16).rjust(8, '0')}"
+    end
+
+    def read_ap(addr, rdata, options = {});
+      options = { r_attempts: 1 }.merge(options)
+
+      apacc_access(addr, 1, random, rdata, options)
+      read_dp('RDBUFF', rdata, options)
+
+      cc "ABS-IF: R-AP:  addr=0x#{addr.to_s(16).rjust(8, '0')}, "\
+                  "rdata=0x#{rdata.to_s(16).rjust(8, '0')}"
+    end
+
+    def write_ap(addr, wdata, options = {});
+      options = { w_attempts: 1 }.merge(options)
+
+      rdata = 0x00000000
+      apacc_access(addr, 0, wdata, rdata, options);
+      $tester.cycle(repeat: @write_ap_dly)
+
+      cc "ABS-IF: W-AP: addr=0x#{addr.to_s(16).rjust(8, '0')}, "\
+                 "wdata=0x#{wdata.to_s(16).rjust(8, '0')}"
+    end
+
+    #-------------------------------------
+    #  lower level helper tasks
+    #-------------------------------------
+    def set_ir(name)
+      new_ir = get_ir_code(name);
+      owner.owner.jtag.write_ir(new_ir, size: 4)           # need to make parameterized!!!
+    end
+
+    def acc_access(name, addr, rwb, wdata, rdata, attempts, options = {});
+      set_ir(name);
+      concat_data = (wdata << 3) | (addr << 1) | rwb
+      attempts.times do
+        if name == 'RDBUFF'
+          r = $dut.reg(:dap)
+          if options[:r_mask] == 'store'
+            r.bits(3..34).store
+          elsif options.key?(:compare_data)
+            r.bits(3..34).data = options[:compare_data]
+          end
+          options = options.merge(size: r.size)
+          owner.owner.jtag.read_dr(r, options)   # need to make parameterized!!!
+        else
+          options = options.merge(size: 35)
+          owner.owner.jtag.write_dr(concat_data, options)   # need to make parameterized!!!
+        end
+      end
+      $tester.cycle(repeat: @acc_access_dly)
+    end
+
+    def dpacc_access(name, rwb, wdata, rdata, options = {});
+      attempts = options[:r_attempts].nil? ? (options[:w_attempts].nil? ? 1 : options[:w_attempts]) : options[:r_attempts]
+      addr = get_dp_addr(name);
+      addr_3_2 = (addr & 0x0C) >> 2
+      acc_access(name, addr_3_2, rwb, wdata, rdata, attempts, options);
+    end
+
+    def set_apselect(addr);
+      _random = random
+      addr = addr & 0xff0000f0;
+      concat_data = (addr & 0xff000000) | (_random & 0x00ffff00) | (addr & 0x000000f0) | (_random & 0x0000000f)
+      if (addr != @current_apaddr)
+        write_dp('SELECT', concat_data);
+      end
+      @current_apaddr = addr;
+    end
+
+    def apacc_access(addr, rwb, wdata, rdata, options = {});
+      attempts = options[:r_attempts].nil? ? (options[:w_attempts].nil? ? 1 : options[:w_attempts]) : options[:r_attempts]
+      set_apselect(addr);
+      addr_3_2 = (addr & 0x0000000C) >> 2
+      acc_access('APACC', addr_3_2, rwb, wdata, rdata, attempts, options);
+    end
+
+    def get_dp_addr(name);
+      case name
+        when 'IDCODE' then    return 0xF
+        when 'CTRL/STAT' then return 0x4
+        when 'SELECT' then    return 0x8
+        when 'RDBUFF' then    return 0xC
+        when 'ABORT' then     return 0x0
+        when 'WCR' then       puts "#{name} is a SW-DP only register"
+        when 'RESEND' then    puts "#{name} is a SW-DP only register"
+        else;             puts "Unknown JTAG-DP register name: #{name}"
+      end
+      0
+    end
+
+    def get_ir_code(name);
+      case name
+        when 'ABORT' then     return JTAGC_ARM_ABORT
+        when 'CTRL/STAT' then return JTAGC_ARM_DPACC
+        when 'SELECT' then    return JTAGC_ARM_DPACC
+        when 'RDBUFF' then    return JTAGC_ARM_DPACC
+        when 'APACC' then     return JTAGC_ARM_APACC
+        when 'IDCODE' then    return JTAGC_ARM_IDCODE
+        when 'RESEND' then    puts "#{name} is a SW-DP only register"
+        else;             puts "Unknown JTAG-DP register name: #{name}"
+      end
+      0
+    end
+
+    def random
+      # rand(4294967295)  # random 32-bit integer
+      0x01234567
+    end
+  end
+end