origen_arm_debug 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 609583b64578afdec4453eaec6425e0eb3ea447c
-  data.tar.gz: fcb99fc0d5ebaf867853fb59055b0a9ee7fc519d
+  metadata.gz: dc238d6a6c1968e247feaf3a6b57c4b6222246e8
+  data.tar.gz: 79ee7b36c4af7d4357fa541937b429a9b596525f
 SHA512:
-  metadata.gz: 2c0c1690d203d8ef3443927bfce7602e1cd6317c736200aa5dc263dd185611a63e97f9f5e4f1bdd0e0eb1690336b7eb93aa9ecf3621d5db372c9bd0c1fb32b9b
-  data.tar.gz: a25d97c6b5791a6418df1954c599b635cf93035cf2a0de695b9b4be8357fc42d66ac993ed53bad71f750c52c7dc3d3bfcc7175927d4fcbe00bc62a9c74a14c9a
+  metadata.gz: f13c97b08406af4d1748cea9ca1ce365cc910a14689f631aa9fc0156e4a454516978e5c4be3a1cc7579021b3df1c55624617ecc06fd9e59bba28fee0ea4a2707
+  data.tar.gz: b061fba3f3ccad2c04cc8b94b0ac8b633aea8a25ac3fc2183cec9f802e110c7829c2990edc71e4c298b8066afaec33872230080bf3c32db356e8f5212ef8d7e1

data/config/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: origen_arm_debug
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Ronnie Lajaunie
@@ -80,17 +80,11 @@ files:
 - config/users.rb
 - config/version.rb
 - lib/origen_arm_debug.rb
-- lib/origen_arm_debug/abs_if_jtag.rb
-- lib/origen_arm_debug/abs_if_swd.rb
-- lib/origen_arm_debug/core_access_M4.rb
 - lib/origen_arm_debug/driver.rb
 - lib/origen_arm_debug/dut.rb
 - lib/origen_arm_debug/dut_jtag.rb
 - lib/origen_arm_debug/dut_swd.rb
-- lib/origen_arm_debug/jtag_ap.rb
-- lib/origen_arm_debug/jtag_dp.rb
 - lib/origen_arm_debug/mem_ap.rb
-- lib/origen_arm_debug/sw_dp.rb
 - lib/origen_arm_debug/swj_dp.rb
 - pattern/read_write_reg.rb
 - templates/web/index.md.erb

data/lib/origen_arm_debug/abs_if_jtag.rb

@@ -1,255 +0,0 @@
-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

data/lib/origen_arm_debug/abs_if_swd.rb

@@ -1,269 +0,0 @@
-# To use this driver the $soc model must define the following pins (an alias is fine):
-#   :swd_clk
-#   :swd_dio
-#
-# API methods:
-#   R_dp -  debug register read - just a dummy function in origen
-#   RE_dp - debug register read/expect - expect compares not implemented
-#   R_ap - read a specific address - just a dummy function in origen
-#   W_dp - debug register write
-#   W_ap - write a specific address
-#   WR_ap - write a specific address, then read back
-
-module OrigenARMDebug
-  class ABSIF_SWD
-    attr_reader :owner
-    include Origen::Registers
-
-    def initialize(owner, options = {})
-      @current_apaddr = 0
-      @orundetect = 0
-      @owner = owner
-    end
-
-    # Highest level implementation of API - abstracted from 'read' and 'write' for future merging with JTAG debug
-    def R_dp(name, rdata, options = {})
-      cc 'Reading ' + name
-      read_dp(name, options)
-    end
-
-    def RE_dp(name, edata, options = {})
-      R_dp(name, edata, options)
-    end
-
-    def R_ap(addr, rdata, options = {})
-      cc 'Reading address ' + addr.to_s(16)
-      read_ap(addr, options)
-    end
-
-    def WAIT_RE_ap(addr, edata, options = {})
-      options = { mask: 0xffffffff, r_attempts: 1 }.merge(options)
-
-      # just assume that it always passes
-      actual = edata
-
-      R_ap(addr, actual, options)
-
-      cc "ABS-IF: WAIT_RE-AP: addr = 0x#{addr.to_s(16)}, "\
-                             "actual = 0x#{actual.to_s(16)}, "\
-                             "expected = 0x#{edata.to_s(16)}, "\
-                             "mask = 0x#{options[:mask].to_s(16)}"
-    end
-
-    def W_dp(name, wdata, options = {})
-      cc 'Writing 0x' + wdata.to_s(16) + ' to ' + name
-      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)
-
-      # just assume that it always passes
-      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)}, "\
-                                "read = 0x#{actual.to_s(16)}, "\
-                                "expected = 0x#{options[:edata].to_s(16)}, "\
-                                "mask = 0x#{options[:mask].to_s(16)}"
-    end
-
-    def W_ap(addr, wdata, options = {})
-      options = { w_attempts: 1 }.merge(options)
-      cc 'Writing 0x' + wdata.to_s(16) + ' to address 0x' + addr.to_s(16)
-      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)
-
-      # just assume that it always passes
-      actual = wdata & options[:mask]
-      W_ap(addr, wdata, options)
-      options.delete(:w_delay) if options.key?(:w_delay)
-      R_ap(addr, actual, options)
-
-      cc "ABS-IF: WR-AP: addr = 0x#{addr.to_s(16)}, "\
-                       "write = 0x#{wdata.to_s(16)}, "\
-                        "read = 0x#{actual.to_s(16)}, "\
-                    "expected = 0x#{options[:edata].to_s(16)}, "\
-                        "mask = 0x#{options[:mask].to_s(16)}"
-    end
-
-    # SWD-specific functions
-    def read_dp(name, options = {})
-      case name
-         when 'IDCODE'    then dpacc_access(name, 1, 0x55555555, options)
-         when 'ABORT'     then cc 'Write only register!'
-         when 'CTRL/STAT' then dpacc_access(name, 1, 0x55555555, options)
-         when 'SELECT'    then cc 'Write only register!'
-         when 'RDBUFF'    then dpacc_access(name, 1, 0x55555555, options)
-         when 'WCR'       then dpacc_access(name, 1, 0x55555555, options)
-         when 'RESEND'    then dpacc_access(name, 1, 0x55555555, options)
-         else cc 'Unknown SW-DP register name'
-      end
-    end
-
-    def write_dp(name, wdata, options = {})
-      case name
-         when 'IDCODE'    then cc 'SW-DP register is read-only'
-         when 'ABORT'     then dpacc_access(name, 0, wdata, options)
-         when 'CTRL/STAT' then dpacc_access(name, 0, wdata, options)
-         when 'SELECT'    then dpacc_access(name, 0, wdata, options)
-         when 'RDBUFF'    then cc 'SW-DP register is read-only'
-         when 'WCR'       then dpacc_access(name, 0, wdata, options)
-         when 'RESEND'    then cc 'SW-DP register is read-only'
-         else cc 'Unknown SW-DP register name'
-      end
-    end
-
-    def write_ap(addr, wdata, options = {})
-      apacc_access(addr, 0, wdata, options)
-    end
-
-    def read_ap(addr, options = {})
-      # Create another copy of options with select keys removed. This first read is junk so we do not want to
-      # store it or compare it.
-      junk_options = options.clone.delete_if do |key, val|
-        (key.eql?(:r_mask) && val.eql?('store')) || key.eql?(:compare_data)
-      end
-      # pass junk options onto the first apacc access
-      apacc_access(addr, 1, 0x55555555, junk_options)
-      read_dp('RDBUFF', options) # This is the real data
-    end
-
-    # Low-level access functions
-    def dpacc_access(name, rwb, wdata, options = {})
-      addr = get_dp_addr(name)
-      if (name == 'CTRL/STAT')
-        cc 'CTRL/STAT'
-        set_apselect(@current_apaddr & 0xFFFFFFFE, options)
-      end
-      if (name == 'WCR')
-        cc 'NOT IMPLEMENTED'
-      end
-
-      acc_access(addr, rwb, 0, wdata, options)
-
-      if (name == 'WCR')
-        cc 'NOT IMPLEMENTED'
-      end
-      if (name == 'CTRL/STAT')
-        @orundetect = wdata & 0x1
-      end
-    end
-
-    def apacc_access(addr, rwb, wdata, options = {})
-      set_apselect((addr & 0xFFFFFFFE) | (@current_apaddr & 1), options)
-      options.delete(:w_delay) if options.key?(:w_delay)
-      acc_access((addr & 0xC), rwb, 1, wdata, options)
-    end
-
-    def get_dp_addr(name)
-      case name
-         when 'IDCODE'    then return 0x0
-         when 'ABORT'     then return 0x0
-         when 'CTRL/STAT' then return 0x4
-         when 'WCR'       then return 0x4
-         when 'RESEND'    then return 0x8
-         when 'SELECT'    then return 0x8
-         when 'RDBUFF'    then return 0xC
-         else cc 'Unknown SW-DP register name'
-      end
-    end
-
-    def acc_access(address, rwb, ap_dp, wdata, options = {})
-      start      = 1
-      apndp      = ap_dp
-      rnw        = rwb
-      addr       = address >> 2
-      parity_pr  = ap_dp ^ rwb ^ (addr >> 3) ^ (addr >> 2) & (0x01) ^ (addr >> 1) & (0x01) ^ addr & 0x01
-      trn        = 0
-      data       = wdata
-      require_dp = @orundetect
-      line_reset = 0
-      stop       = 0
-      park       = 1
-
-      cc 'SWD transaction'
-      cc 'Packet Request Phase'
-
-      annotate 'Send Start Bit'
-      owner.owner.swd.send_data(start, 1)
-      cc('Send APnDP Bit (DP or AP Access Register Bit)', prefix: true)
-      owner.owner.swd.send_data(apndp,      1)
-      c2 'Send RnW Bit (read or write bit)'
-      owner.owner.swd.send_data(rnw,        1)
-      c2 'Send Address Bits (2 bits)'
-      owner.owner.swd.send_data(addr,       2)
-      c2 'Send Parity Bit'
-      owner.owner.swd.send_data(parity_pr,  1)
-      c2 'Send Stop Bit'
-      owner.owner.swd.send_data(stop,       1)
-      c2 'Send Park Bit'
-      owner.owner.swd.send_data(park,       1)
-
-      cc 'Acknowledge Response phase'
-      owner.owner.swd.send_data(0xf, trn + 1)
-      owner.owner.swd.get_data (3)
-      cc 'Read/Write Data Phase'
-      if (rwb == 1)
-        cc 'Read'
-        if options[:r_mask] == 'store'
-          owner.owner.pin(:swd_dio).store
-        end
-        cc 'SWD 32-Bit Read Data Start'
-        owner.owner.swd.get_data(32, options)
-        cc 'SWD 32-Bit Read Data End'
-        cc 'Get Read Parity Bit'
-        owner.owner.swd.get_data(1)
-        cc 'Send Read ACK bits'
-        owner.owner.swd.send_data(0xf, trn + 1)
-      else
-        cc 'Write'
-        cc 'Send ACK Bits'
-        owner.owner.swd.send_data(0xf, trn + 1)
-        cc 'SWD 32-Bit Write Start'
-        owner.owner.swd.send_data(data, 32, options)
-        cc 'SWD 32-Bit Write End'
-        cc 'Send Write Parity Bit'
-        owner.owner.swd.send_data(swd_xor_calc(32, data), 1)
-      end
-
-      if options.key?(:w_delay)
-        cc "SWD DIO to 0 for #{options[:w_delay]} cycles"
-        owner.owner.swd.swd_dio_to_0(options[:w_delay])
-      else
-        cc 'SWD DIO to 0 for 10 cycles'
-        owner.owner.swd.swd_dio_to_0(10)
-      end
-    end
-
-    def set_apselect(addr, options = {})
-      addr &= 0xff0000f1
-      cc "SET_APSelect: addr = 0x#{addr.to_s(16)} "
-
-      if (addr != @current_apaddr)
-        cc 'SET_APSelect: write_dp SELECT'
-        write_dp('SELECT', addr & 0xff0000ff, options)
-      end
-
-      @current_apaddr = addr
-    end
-
-    # Calculate exclusive OR
-    def swd_xor_calc(size, number)
-      xor = 0
-      size.times do |bit|
-        xor ^= (number >> bit) & 0x01
-      end
-      xor
-    end
- end
-end