origen_swd 0.5.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e19e934c3c7bbb7092cad11d2d69b97be46ee52e
-  data.tar.gz: 07ff3368c8d0e9ed1904a81602d8d0a52c7a1399
+  metadata.gz: c8c309c479f7909b8266f9e642dbbe614b0ef8ed
+  data.tar.gz: 0623f5d41b8a0ae7cb9fa527ecbdf1fbdf940ef2
 SHA512:
-  metadata.gz: a4f9830d179fdaf7fe1f0cb51edf3b9408a2d2d848c8fa695a02de307f50d7504a28bac50dad2006585d99e7a9a1137044e12fe8ce0e54007d7b976406d58eff
-  data.tar.gz: 5460db3c0c1388a17f0f5eb1e049f898330c2d56fb7f5c97a151d351580ab41d5d88277cfa2ee96df16abe19ea07e3a887e89ff6e1067a7d1a63c44fd94cd888
+  metadata.gz: 9b52f1c3ea5db823849cc1afb0dbea312a7aab30d41a389a101215059b82e4318346395e3443b1aa0557c900ab55705b1d2c4eda7f11721de355a2630c9d503a
+  data.tar.gz: f2cc61effbb85769c07d915ca27c44befe1664c86f362e8e8faabd2e417604edfe9e2a6da04b50a2efeb39713b7ea307eec948aef98f6c7285eb3205508013c1

data/config/boot.rb

@@ -0,0 +1,2 @@
+require "origen_swd"
+require 'origen_swd_dev/dut'

data/config/commands.rb

@@ -22,8 +22,6 @@ when "examples"
   status = 0
   
   # Pattern generator tests
-  ARGV = %w(example -t debug -r approved)
-  load "#{Origen.top}/lib/origen/commands/generate.rb"
   ARGV = %w(example_api -t debug -r approved)
   load "#{Origen.top}/lib/origen/commands/generate.rb"
   ARGV = %w(example_reg -t debug -r approved)

data/config/version.rb

@@ -1,6 +1,6 @@
 module OrigenSWD
-  MAJOR = 0
-  MINOR = 5
+  MAJOR = 1
+  MINOR = 0
   BUGFIX = 0
   DEV = nil
 

data/lib/origen_swd/driver.rb

@@ -11,6 +11,8 @@ module OrigenSWD
     # Returns the parent object that instantiated the driver, could be
     # either a DUT object or a protocol abstraction
     attr_reader :owner
+
+    # Customiz-ible 'turn-round cycle' (TRN) parameter (in cycles)
     attr_accessor :trn
 
     # Initialize class variables
@@ -24,13 +26,36 @@ module OrigenSWD
     #
     def initialize(owner, options = {})
       @owner = owner
-      # validate_pins
 
       @current_apaddr = 0
       @orundetect = 0
       @trn = 0
     end
 
+    # Write data from Debug Port
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be shifted. If a reg/bit collection is supplied this can be pre-marked for
+    #   read, store or overlay and which will result in the requested action being applied to
+    #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
+    # @param [Hash] options Options to customize the operation
+    def read_dp(reg_or_val, options = {})
+      reg_or_val, options = nil, reg_or_val if reg_or_val.is_a?(Hash)
+      read(0, reg_or_val, options.merge(compare_data: reg_or_val.is_a?(Numeric)))
+    end
+
+    # Write data from Access Port
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be shifted. If a reg/bit collection is supplied this can be pre-marked for
+    #   read, store or overlay and which will result in the requested action being applied to
+    #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
+    # @param [Hash] options Options to customize the operation
+    def read_ap(reg_or_val, options = {})
+      reg_or_val, options = nil, reg_or_val if reg_or_val.is_a?(Hash)
+      read(1, reg_or_val, options.merge(compare_data: reg_or_val.is_a?(Numeric)))
+    end
+
     # Read data from Debug Port or Access Port
     #
     # @param [Integer] ap_dp A single bit indicating whether the Debug Port or the Access Port
@@ -41,10 +66,33 @@ module OrigenSWD
     #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
     # @param [Hash] options Options to customize the operation
     def read(ap_dp, reg_or_val, options = {})
-      addr = reg_or_val.respond_to?(:address) ? reg_or_val.address : reg_or_val
+      addr = extract_address(reg_or_val, options.merge(use_reg_or_val_if_you_must: true))
       send_header(ap_dp, 1, addr)       # send read-specific header (rnw = 1)
       receive_acknowledgement
       receive_payload(reg_or_val, options)
+      swd_dio.drive(0)
+    end
+
+    # Write data to Debug Port
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be shifted. If a reg/bit collection is supplied this can be pre-marked for
+    #   read, store or overlay and which will result in the requested action being applied to
+    #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
+    # @param [Hash] options Options to customize the operation
+    def write_dp(reg_or_val, options = {})
+      write(0, reg_or_val, options)
+    end
+
+    # Write data to Access Port
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be shifted. If a reg/bit collection is supplied this can be pre-marked for
+    #   read, store or overlay and which will result in the requested action being applied to
+    #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
+    # @param [Hash] options Options to customize the operation
+    def write_ap(reg_or_val, options = {})
+      write(1, reg_or_val, options)
     end
 
     # Write data to Debug Port or Access Port
@@ -55,81 +103,48 @@ module OrigenSWD
     #   Value to be shifted. If a reg/bit collection is supplied this can be pre-marked for
     #   read, store or overlay and which will result in the requested action being applied to
     #   the cycles corresponding to those bits only (don't care cycles will be generated for the others).
-    # @param [Integer] wdata Data to be written
     # @param [Hash] options Options to customize the operation
-    def write(ap_dp, reg_or_val, wdata, options = {})
-      addr = reg_or_val.respond_to?(:address) ? reg_or_val.address : reg_or_val
-      send_header(ap_dp, 0, addr)       # send write-specific header (rnw = 0)
-      receive_acknowledgement
+    def write(ap_dp, reg_or_val, deprecated_wdata = nil, options = {})
+      deprecated_wdata, options = nil, deprecated_wdata if deprecated_wdata.is_a?(Hash)
 
-      if reg_or_val.respond_to?(:data)
-        reg_or_val.data = wdata
+      if deprecated_wdata
+        addr = reg_or_val.respond_to?(:address) ? reg_or_val.address : reg_or_val
       else
-        reg_or_val = wdata
+        addr = extract_address(reg_or_val, options)
       end
-      send_payload(reg_or_val, options)
-    end
 
-    # Sends data stream with SWD protocol
-    #
-    # @param [Integer] data Data to be sent
-    # @param [Integer] size The length of data
-    # @param [Hash] options Options to customize the operation
-    # @option options [String] :overlay String for pattern label to
-    #   facilitate pattern overlay
-    def send_data(data, size, options = {})
-      # Warn caller that this method is being deprecated
-      msg = 'Use swd.write(ap_dp, reg_or_val, wdata, options = {}) instead of send_data(data, size, options = {})'
-      Origen.deprecate msg
-      if options.key?(:overlay)
-        $tester.label(options[:overlay])
-        size.times do |bit|
-          swd_clk.drive(1)
-          $tester.label("// SWD Data Pin #{bit}")
-          swd_dio.drive(data[bit])
-          $tester.cycle
-        end
-        swd_dio.dont_care
-      else
-        size.times do |bit|
-          swd_clk.drive(1)
-          swd_dio.drive(data[bit])
-          $tester.cycle
+      send_header(ap_dp, 0, addr)       # send write-specific header (rnw = 0)
+      receive_acknowledgement
+
+      if deprecated_wdata
+        if reg_or_val.respond_to?(:data)
+          reg_or_val.data = deprecated_wdata
+        else
+          reg_or_val = deprecated_wdata
         end
-        swd_dio.dont_care
       end
+      send_payload(reg_or_val, options)
+      swd_dio.drive(0)
     end
 
-    # Recieves data stream with SWD protocol
-    #
-    # @param [Integer] size The length of data
-    # @param [Hash] options Options to customize the operation
-    # @option options [String] :compare_data Data to be compared, only compared
-    #   if options is set
-    def get_data(size, options = {})
-      # Warn caller that this method is being deprecated
-      msg = 'Use swd.read(ap_dp, reg_or_val, options = {}) instead of get_data(size, options = {})'
-      Origen.deprecate msg
-      should_store = swd_dio.is_to_be_stored?
-      swd_dio.dont_care
-      size.times do |bit|
-        $tester.store_next_cycle($dut.pin(:swd_dio)) if should_store
-        swd_dio.assert(options[:compare_data][bit]) if options.key?(:compare_data)
-        $tester.cycle
-      end
-    end
+    private
 
-    # Sends specified number of '0' bits
-    #
-    # @param [Integer] size The length of data
-    def swd_dio_to_0(size)
-      swd_dio.drive(0)
-      size.times do |bit|
-        $tester.cycle
+    def extract_data_hex(reg_or_val)
+      if reg_or_val.respond_to?(:data)
+        reg_or_val.data.to_s(16).upcase
+      else
+        reg_or_val.to_s(16).upcase
       end
     end
 
-    private
+    def extract_address(reg_or_val, options)
+      addr = options[:address] || options[:addr]
+      return addr if addr
+      return reg_or_val.address if reg_or_val.respond_to?(:address)
+      return reg_or_val.addr if reg_or_val.respond_to?(:addr)
+      return reg_or_val if reg_or_val && options[:use_reg_or_val_if_you_must]
+      fail 'No address given, if supplying a data value instead of a register object, you must supply an :address option'
+    end
 
     # Send SWD Packet header
     #   ------------------------------------------------------------------------
@@ -145,40 +160,44 @@ module OrigenSWD
       addr = address >> 2
       parity  = apndp ^ rnw ^ (addr >> 3) ^ (addr >> 2) & (0x01) ^ (addr >> 1) & (0x01) ^ addr & 0x01
 
-      cc 'Header phase'
+      cc '[SWD] -----------------------------------------------------------------'
+      cc '[SWD] | Start |  AP   | Read  | AD[2] | AD[3] |  Par  | Stop  | Park  |'
+      cc "[SWD] |   1   |   #{apndp}   |   #{rnw}   |   #{addr[0]}   |   #{addr[1]}   |   #{parity[0]}   |   0   |   1   |"
+      cc '[SWD] -----------------------------------------------------------------'
       swd_clk.drive(1)
-      cc 'Send Start Bit'
       swd_dio.drive!(1)                                   # send start bit (always 1)
-      cc 'Send APnDP Bit (DP or AP Access Register Bit)'
       swd_dio.drive!(apndp)                               # send apndp bit
-      cc 'Send RnW Bit (read or write bit)'
       swd_dio.drive!(rnw)                                 # send rnw bit
-      cc 'Send Address Bits (2 bits)'
       swd_dio.drive!(addr[0])                             # send address[2] bit
       swd_dio.drive!(addr[1])                             # send address[3] bit
-      cc 'Send Parity Bit'
       swd_dio.drive!(parity[0])                           # send parity bit
-      cc 'Send Stop Bit'
       swd_dio.drive!(0)                                   # send stop bit
-      cc 'Send Park Bit'
       swd_dio.drive!(1)                                   # send park bit
       swd_dio.dont_care
     end
 
     # Waits appropriate number of cycles for the acknowledgement phase
     def receive_acknowledgement
-      cc 'Acknowledge Response phase'
       wait_trn
+      swd_dio.assert!(1)
+      swd_dio.assert!(0)
+      swd_dio.assert!(0)
       swd_dio.dont_care
-      $tester.cycle(repeat: 3)
     end
 
     # Waits for TRN time delay
     def wait_trn
-      swd_dio.drive(1)
       $tester.cycle(repeat: trn + 1)
     end
 
+    def log(msg)
+      cc "[SWD] #{msg}"
+      if block_given?
+        yield
+        cc "[SWD] /#{msg}"
+      end
+    end
+
     # Get (read) the data payload
     #
     # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
@@ -188,17 +207,12 @@ module OrigenSWD
     # @option options [String] :overlay String for pattern label to
     #   facilitate pattern overlay
     def receive_payload(reg_or_val, options)
-      cc 'Read Data Payload phase'
-
-      cc 'SWD 32-Bit Read Data Start'
-      options[:read] = true
-      shift_payload(reg_or_val, options)
-
-      cc 'SWD 32-Bit Read Data End'
-      cc 'Get Read Parity Bit'
+      log "Read: #{Origen::Utility.read_hex(reg_or_val)}" do
+        options[:read] = true
+        shift_payload(reg_or_val, options)
+      end
       swd_dio.dont_care
       $tester.cycle
-      cc 'Send Read ACK bits'
       wait_trn
     end
 
@@ -211,18 +225,17 @@ module OrigenSWD
     # @option options [String] :overlay String for pattern label to
     #   facilitate pattern overlay
     def send_payload(reg_or_val, options)
-      cc 'Write Data Payload phase'
-      cc 'Send ACK Bits'
       wait_trn
+      wdata = reg_or_val.respond_to?(:data) ? reg_or_val.data : reg_or_val
 
-      cc 'SWD 32-Bit Write Start'
-      options[:read] = false
-      shift_payload(reg_or_val, options)
+      log "Write: #{wdata.to_hex}" do
+        options[:read] = false
+        shift_payload(reg_or_val, options)
+      end
 
-      cc 'Send Write Parity Bit'
-      wdata = reg_or_val.respond_to?(:data) ? reg_or_val.data : reg_or_val
       parity_bit = swd_xor_calc(32, wdata)
       swd_dio.drive!(parity_bit)
+      swd_dio.dont_care
     end
 
     # Shift the data payload
@@ -259,13 +272,13 @@ module OrigenSWD
               $tester.label(reg_or_val[i].overlay_str)
             elsif reg_or_val[i].is_to_be_read?
               swd_dio.assert(reg_or_val[i] ? reg_or_val[i] : 0)
-            elsif options.key?(:compare_data)
+            elsif options[:compare_data]
               swd_dio.assert(reg_or_val[i] ? reg_or_val[i] : 0)
             else
               swd_dio.dont_care
             end
           else
-            if options.key?(:compare_data)
+            if options[:compare_data] && reg_or_val
               swd_dio.assert(reg_or_val[i] ? reg_or_val[i] : 0)
             else
               swd_dio.dont_care
@@ -295,12 +308,12 @@ module OrigenSWD
       xor
     end
 
-    # Provided shortname access to top-level SWD clock pin
+    # Provides shortname access to top-level SWD clock pin
     def swd_clk
       owner.pin(:swd_clk)
     end
 
-    # Provided shortname access to top-level SWD data I/P pin
+    # Provides shortname access to top-level SWD data I/O pin
     def swd_dio
       owner.pin(:swd_dio)
     end

data/lib/{origen_swd → origen_swd_dev}/dut.rb

@@ -1,14 +1,12 @@
-module OrigenSWD
+module OrigenSWDDev
   # This is a dummy DUT model which is used
   # to instantiate and test the SWD locally
   # during development.
   #
   # It is not included when this library is imported.
   class DUT
+    include Origen::TopLevel
     include OrigenSWD
-    include Origen::Callbacks
-    include Origen::Registers
-    include Origen::Pins
 
     # Initializes simple dut model with test register and required swd pins
     #

data/pattern/example_api.rb

@@ -1,37 +1,21 @@
 Pattern.create do
-  DP = 0
-  AP = 1
-  ap_dp      = 1
-  address    = 0x00002020
-  wdata      = 0xAAAA5555
+  dut.control.write(0x00000010)
+  dut.swd.write(0, dut.control)
+  dut.swd.write(0, 0x55, address: 4)
+  dut.swd.write_dp(dut.control)
+  dut.swd.write_dp(0x55, address: 4)
+  dut.swd.write_ap(dut.control)
+  dut.swd.write_ap(0x55, address: 4)
 
-
-  $dut.swd.write(ap_dp, address, wdata, overlay: 'write_ovl')
-  cc 'SWD DIO to 0 for 10 cycles'
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(ap_dp, address)
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(ap_dp, address, compare_data: wdata)
-  $dut.swd.swd_dio_to_0(10)
-
-  #$dut.reg(:select).data = 0x01000000
-  $dut.swd.write(DP, $dut.reg(:select), 0x01000000, arm_debug_overlay: 'select_reg')
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(DP, $dut.reg(:select))
-  $dut.swd.swd_dio_to_0(10)
-
-  $dut.swd.write(DP, $dut.reg(:stat), 0x00000032)
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.write(DP, $dut.reg(:control), 0x00000010)
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(DP, $dut.reg(:control), r_mask: 'store')
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(DP, $dut.reg(:control), compare_data: 0x00000010)
-  $dut.swd.swd_dio_to_0(10)
-
-  $dut.swd.read(DP, $dut.reg(:control), compare_data: 0x00000010)
-  $dut.swd.swd_dio_to_0(10)
-  $dut.swd.read(DP, $dut.reg(:control), compare_data: 0x00000010)
-  $dut.swd.swd_dio_to_0(10)
+  # Not really supported, can't differentiate between an old-style and new-style
+  # call to do things like enable read by default
+  #dut.swd.read(DP, dut.control)
+  #dut.swd.read(DP, 0x55, address: 4)
+  dut.swd.read_dp(dut.control)
+  dut.swd.read_dp(0x55, address: 4)
+  dut.swd.read_ap(dut.control)
+  dut.swd.read_ap(0x55, address: 4)
+  dut.swd.read_dp(address: 4)
+  dut.swd.read_ap(address: 4)
 
 end

data/templates/web/index.md.erb

@@ -27,7 +27,7 @@ __NOTE:__ You will also need to include <code>require 'origen_swd'</code> somewh
 
 ### How To Use
 
-Include the <code>OrigenSWD</code> module to add a JTAG driver to your class and
+Include the <code>OrigenSWD</code> module to add a SWD driver to your class and then
 define the required pins.
 
 Including the module adds a <code>swd</code> method which will return an instance of
@@ -38,8 +38,8 @@ Here is an example integration:
 ~~~ruby
 
 class DUT
+  include Origen::TopLevel
   include OrigenSWD
-  include Origen::Pins 
 
   def initialize(options = {})
     add_pin :swd_clk 
@@ -48,7 +48,29 @@ class DUT
 end
 
 
-DUT.new.swd # => An instance of OrigenSWD::Driver
+dut.swd # => An instance of OrigenSWD::Driver
+
+# Here is the main API for reading and writing the debug and access ports...
+
+# Registers objects can be supplied to provide the address and data values.
+# The register bits can be pre-marked for read, store or overlay and which
+# will result in the requested action being applied to the cycles corresponding
+# to those bits only (don't care cycles will be generated for the others).
+dut.swd.write_dp(reg_object)    
+dut.swd.read_dp(reg_object)    
+dut.swd.write_ap(reg_object)    
+dut.swd.read_ap(reg_object)    
+
+# Alternatively, dumb data values can be supplied.
+dut.swd.write_dp(0x55, address: 10)
+dut.swd.read_dp(0x55, address: 10)    
+dut.swd.write_ap(0x55, address: 10)    
+dut.swd.read_ap(0x55, address: 10)    
+
+# In the case of read, the data value can be omitted completely, in which case
+# it will generate a read operation with don't care on all shift out vectors
+dut.swd.read_dp(address: 10)    
+dut.swd.read_ap(address: 10)    
 ~~~
 
 
@@ -62,7 +84,7 @@ object for use in the console:
 ~~~
 origen i
 
-> $dut.swd
+> dut.swd
 => #<OrigenSWD::Driver:0x0000001ee48e78>
 ~~~
 

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: origen_swd
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ronnie Lajaunie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-24 00:00:00.000000000 Z
+date: 2017-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-- !ruby/object:Gem::Dependency
-  name: origen_doc_helpers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
-  type: :development
+        version: 0.7.36
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.7.36
 description: 
 email:
 - Ronnie.Lajaunie@freescale.com
@@ -46,15 +32,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/application.rb
+- config/boot.rb
 - config/commands.rb
-- config/development.rb
-- config/environment.rb
-- config/users.rb
 - config/version.rb
 - lib/origen_swd.rb
 - lib/origen_swd/driver.rb
-- lib/origen_swd/dut.rb
-- pattern/example.rb
+- lib/origen_swd_dev/dut.rb
 - pattern/example_api.rb
 - pattern/example_reg.rb
 - templates/web/index.md.erb
@@ -81,9 +64,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Driver for single-wire-debug interface.
 test_files: []
-has_rdoc: 

data/config/development.rb

@@ -1,15 +0,0 @@
-# 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 OrigenSWD
-  autoload :DUT, "origen_swd/dut"
-end

data/config/environment.rb

@@ -1 +0,0 @@
-require "origen_swd"

data/config/users.rb

@@ -1,19 +0,0 @@
-# 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/pattern/example.rb

@@ -1,59 +0,0 @@
-Pattern.create do
-
-  address    = 0x00002020
-  rwb        = 0
-  ap_dp      = 1
-  wdata      = 0xAAAA5555
-  start      = 1
-  apndp      = 1
-  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 = 0
-  line_reset = 0
-  stop       = 0
-  park       = 1
-
-  cc 'SWD transaction'
-  cc 'Packet Request Phase'
-
-  annotate 'Send Start Bit'
-  $dut.swd.send_data(start, 1)
-  cc('Send APnDP Bit (DP or AP Access Register Bit)', prefix: true)
-  $dut.swd.send_data(apndp, 1)
-  c2 'Send RnW Bit (read or write bit)'
-  $dut.swd.send_data(rnw, 1)
-  c2 'Send Address Bits (2 bits)'
-  $dut.swd.send_data(addr, 2)
-  c2 'Send Parity Bit'
-  $dut.swd.send_data(parity_pr, 1)
-  c2 'Send Stop Bit'
-  $dut.swd.send_data(stop, 1)
-  c2 'Send Park Bit'
-  $dut.swd.send_data(park, 1)
-
-  cc 'Acknowledge Response phase'
-  $dut.swd.send_data(0xf, trn + 1)
-  $dut.swd.get_data(3)
-
-  cc 'Write Data Phase'
-  cc 'Write'
-  cc 'Send ACK Bits'
-  $dut.swd.send_data(0xf, trn + 1)
-  cc 'SWD 32-Bit Write Start'
-  $dut.swd.send_data(data, 32, overlay: 'write_ovl')
-  cc 'SWD 32-Bit Write End'
-  cc 'Send Write Parity Bit'
-  xor = 0
-  32.times do |bit|
-    xor ^= (data >> bit) & 0x01
-  end
-  xor
-  $dut.swd.send_data(xor, 1)
-
-  cc 'SWD DIO to 0 for 10 cycles'
-  $dut.swd.swd_dio_to_0(10)
-
-end