origen_jtag 0.12.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e06b3dca12b20579f6fbfbc389dac204e960a93b
+  data.tar.gz: dc97efa495078334d68ce6ac8bd43fcea8b2467d
+SHA512:
+  metadata.gz: 43f03422ef2359a8e10a527300824d84e29f92cd97934b535d69f12e73aa480163790a06041b991bb25d5c05a76c491dcef9428db0cdaed7b5f3b7c33359e134
+  data.tar.gz: b84f766c5f4dd19cc111fad60e4f55c2162f2b09c4abff4c2d4016b5a97b0ff036e75393517e8488b87af9da552d26b0fc28a0e8fe48d1f9765f449bf15e0433

data/config/application.rb

@@ -0,0 +1,64 @@
+class OrigenJTAGApplication < Origen::Application
+
+  # This file contains examples of some of the most common configuration options,
+  # to see a real production example from a large application have a look at:
+  # sync://sync-15088:15088/Projects/common_tester_blocks/blocks/C90TFS_NVM_tester/tool_data/origen_v2/config/application.rb
+
+  # This information is used in headers and email templates, set it specific
+  # to your application
+  config.name     = "Origen JTAG"
+  config.initials = "OrigenJTAG"
+  # Force naming for gem, done here because JTAG will not automatically convert to
+  # 'jtag' when OrigenJTAG is snakecased
+  self.name = "origen_jtag"
+  self.namespace = "OrigenJTAG"
+  config.rc_url   = "git@github.com:Origen-SDK/origen_jtag.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/jtag"
+  config.web_domain = "http://origen-sdk.org/jtag"
+
+  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,90 @@
+# This file should be used to extend the origen command line tool with tasks 
+# specific to your application.
+# The comments below should help to get started and you can also refer to
+# lib/origen/commands.rb in your Origen core workspace for more examples and 
+# inspiration.
+#
+# Also see the official docs on adding commands:
+#   http://origen.freescale.net/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
+
+def path_to_coverage_report
+  require 'pathname'
+  Pathname.new("#{Origen.root}/coverage/index.html").relative_path_from(Pathname.pwd)
+end
+
+def enable_coverage(name, merge=true)
+  if ARGV.delete("-c") || ARGV.delete("--coverage")
+    require 'simplecov'
+    SimpleCov.start do
+      command_name name
+
+      at_exit do
+        SimpleCov.result.format!
+        puts ""
+        puts "To view coverage report:"
+        puts "  firefox #{path_to_coverage_report} &"
+        puts ""
+      end
+    end
+    yield
+  else
+    yield
+  end
+end
+
+# Now branch to the specific task code
+case @command
+
+when "examples"  
+  Origen.load_application
+  enable_coverage("examples") do 
+
+    # Pattern generator tests
+    ARGV = %w(jtag_workout -t v93k.rb -r approved)
+    load "#{Origen.top}/lib/origen/commands/generate.rb"
+    ARGV = %w(jtag_workout -t debug_RH1 -r approved)
+    load "#{Origen.top}/lib/origen/commands/generate.rb"
+    ARGV = %w(jtag_workout -t debug_RL1 -r approved)
+    load "#{Origen.top}/lib/origen/commands/generate.rb"
+
+    ARGV = %w(jtag_workout -t v93k_RH4.rb -r approved)
+    load "#{Origen.top}/lib/origen/commands/generate.rb"
+    ARGV = %w(jtag_workout -t debug_RH4 -r approved)
+    load "#{Origen.top}/lib/origen/commands/generate.rb"
+    ARGV = %w(jtag_workout -t debug_RL4 -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
+    end
+    puts ""
+  end
+  exit 0
+
+# 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,15 @@
+# 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 OrigenJTAG
+  autoload :DUT, "origen_jtag/dut"
+end

data/config/environment.rb

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

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 OrigenJTAG
+  MAJOR = 0
+  MINOR = 12
+  BUGFIX = 0
+  DEV = nil
+
+  VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
+end

data/lib/origen_jtag/driver.rb

@@ -0,0 +1,449 @@
+module OrigenJTAG
+  # This driver provides methods to read and write from a JTAG instruction
+  # and data registers.
+  #
+  # Low level methods are also provided for fine control of the TAP Controller
+  # state machine via the TAPController module.
+  #
+  # To use this driver the parent model must define the following pins (an alias is fine):
+  #   :tclk
+  #   :tdi
+  #   :tdo
+  #   :tms
+  class Driver
+    REQUIRED_PINS = [:tclk, :tdi, :tdo, :tms]
+
+    include TAPController
+    include Origen::Registers
+
+    # Returns the object that instantiated the JTAG
+    attr_reader :owner
+
+    # Returns the current value in the instruction register
+    attr_reader :ir_value
+
+    attr_accessor :tclk_format
+    # Set true to print out debug comments about all state transitions
+    attr_accessor :verbose
+    alias_method :verbose?, :verbose
+
+    def initialize(owner, options = {})
+      @owner = owner
+      validate_pins
+
+      # The parent can configure JTAG settings by defining this constant
+      if defined?(owner.class::JTAG_CONFIG)
+        options = owner.class::JTAG_CONFIG.merge(options)
+      end
+
+      # Fallback defaults
+      options = {
+        verbose:         false,
+        tclk_format:     :rh,                  # format of JTAG clock used:  ReturnHigh (:rh), ReturnLo (:rl)
+        tclk_multiple:   1,                  # number of cycles for one clock pulse, assumes 50% duty cycle. Uses tester non-return format to spread TCK across multiple cycles.
+        #    e.g. @tclk_multiple = 2, @tclk_format = :rh, means one cycle with Tck low (non-return), one with Tck high (NR)
+        #         @tclk_multiple = 4, @tclk_format = :rl, means 2 cycles with Tck high (NR), 2 with Tck low (NR)
+        tdo_strobe:      :tclk_high,            # when using multiple cycles for TCK, when to strobe for TDO, options include:
+        #     :tclk_high   - strobe TDO only when TCK is high
+        #     :tclk_low    - strobe TDO only when TCK is low
+        #     :tclk_all    - strobe TDO throughout TCK cycle
+        tdo_store_cycle: 0,                # store vector cycle within TCK (i.e. when to indicate to tester to store vector within TCK cycle.  0 is first vector, 1 is second, etc.)
+        # NOTE: only when user indicates to store TDO, which will mean we don't care the 1 or 0 value on TDO (overriding effectively :tdo_strobe option above)
+        init_state:      :unknown
+      }.merge(options)
+
+      init_tap_controller(options)
+
+      @verbose = options[:verbose]
+      @ir_value = :unknown
+      @tclk_format = options[:tclk_format]
+      @tclk_multiple = options[:tclk_multiple]
+      @tdo_strobe = options[:tdo_strobe]
+      @tdo_store_cycle = options[:tdo_store_cycle]
+      @state = options[:init_state]
+    end
+
+    # Shift data into the TDI pin or out of the TDO pin.
+    #
+    # There is no TAP controller state checking or handling here, it just
+    # shifts some data directly into the pattern, so it is assumed that some
+    # higher level logic is co-ordinating the TAP Controller.
+    #
+    # Most applications should not call this method directly and should instead
+    # use the pre-packaged read/write_dr/ir methods.
+    # However it is provided as a public API for the corner cases like generating
+    # an overlay subroutine pattern where it would be necessary to generate some JTAG
+    # vectors outwith the normal state controller wrapper.
+    #
+    # @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
+    # @option options [Integer] :size The number of bits to shift. This is optional
+    #   when supplying a register or bit collection in which case the size will be derived from
+    #   the number of bits supplied. If this option is supplied then it will override
+    #   the size derived from the bits. If the size is greater than the number of bits
+    #   provided then the additional space will be padded by 0s or don't cares as appropriate.
+    # @option options [Boolean] :read (false) When true the given value will be compared on the TDO pin
+    #   instead of being shifted into the TDI pin. In the case of a register object being provided
+    #   only those bits that are actually marked for read will be compared.
+    # @option options [Boolean] :cycle_last (false) Normally the last data bit is applied to the
+    #   pins but not cycled, this is to integrate with the TAPController which usually
+    #   requires that the TMS value is also changed on the last data bit. To override this
+    #   default behavior and force a cycle for the last data bit set this to true.
+    # @option options [Boolean] :includes_last_bit (true) When true the TMS pin will be driven
+    #   to 1 on the last cycle of the shift if :cycle_last has been specified. To override this
+    #   and keep TMS low on the last cycle set this to false. One reason for doing this would be
+    #   if generating some subroutine vectors which only represented a partial section of a shift
+    #   operation.
+    def shift(reg_or_val, options = {})
+      options = {
+        read:              false,
+        cycle_last:        false,
+        includes_last_bit: true
+      }.merge(options)
+      size = extract_size(reg_or_val, options)
+      if options.key?(:arm_debug_comment)
+        cc options[:arm_debug_comment]
+      end
+      if options.key?(:arm_debug_overlay)
+        $tester.label(options[:arm_debug_overlay])
+      end
+      size = extract_size(reg_or_val, options)
+      contains_bits = (contains_bits?(reg_or_val) || is_a_bit?(reg_or_val))
+      owner.pin(:tdi).drive(0) # Drive state when reading out
+      owner.pin(:tms).drive(0)
+      size.times do |i|
+        call_subroutine = false
+        if options[:read]
+          # If it's a register support bit-wise reads
+          if contains_bits
+            if reg_or_val[i]
+              if reg_or_val[i].is_to_be_stored?
+                Origen.tester.store_next_cycle(owner.pin(:tdo))
+                owner.pin(:tdo).dont_care if Origen.tester.j750?
+              elsif reg_or_val[i].has_overlay?
+                if Origen.mode.simulation?
+                  owner.pin(:tdo).dont_care
+                else
+                  call_subroutine = reg_or_val[i].overlay_str
+                end
+              elsif reg_or_val[i].is_to_be_read?
+                owner.pin(:tdo).assert(reg_or_val[i] ? reg_or_val[i] : 0)
+              elsif options.key?(:compare_data)
+                if i.eql?(0) || i.eql?(1) || i.eql?(2)
+                  # Skip comparing first three status bits
+                  owner.pin(:tdo).dont_care
+                else
+                  owner.pin(:tdo).assert(reg_or_val[i] ? reg_or_val[i] : 0)
+                end
+              else
+                owner.pin(:tdo).dont_care
+              end
+            # If the read width extends beyond the register boundary, don't care
+            # the extra bits
+            else
+              owner.pin(:tdo).dont_care
+            end
+          # Otherwise read the whole thing
+          else
+            owner.pin(:tdo).assert(reg_or_val[i] ? reg_or_val[i] : 0)
+          end
+        else
+          if contains_bits && reg_or_val[i] && reg_or_val[i].has_overlay?
+            if Origen.mode.simulation?
+              owner.pin(:tdi).drive(reg_or_val[i] ? reg_or_val[i] : 0)
+            else
+              call_subroutine = reg_or_val[i].overlay_str
+            end
+          elsif options.key?(:arm_debug_overlay)
+            if Origen.mode.simulation?
+              owner.pin(:tdi).drive(reg_or_val[i] ? reg_or_val[i] : 0)
+            else
+              $tester.label('// JTAG DATA Pin: ' + i.to_s)
+              owner.pin(:tdi).drive(reg_or_val[i] ? reg_or_val[i] : 0)
+            end
+          else
+            owner.pin(:tdi).drive(reg_or_val[i] ? reg_or_val[i] : 0)
+          end
+        end
+        if call_subroutine
+          Origen.tester.call_subroutine(call_subroutine)
+          @last_data_vector_shifted = true
+        else
+          @last_data_vector_shifted = false
+          # Don't latch the last bit, that will be done when
+          # leaving the state.
+          if i != size - 1 || options[:cycle_last]
+            if i == size - 1 && options[:includes_last_bit]
+              owner.pin(:tms).drive(1)
+            end
+            tclk_cycle do
+              Origen.tester.cycle
+            end
+            owner.pin(:tdo).dont_care
+          else
+            @deferred_compare = true
+          end
+        end
+      end
+      # Clear read and similar flags to reflect that the request has just
+      # been fulfilled
+      reg_or_val.clear_flags if reg_or_val.respond_to?(:clear_flags)
+    end
+
+    # Cycles the tester through one TCLK cycle
+    # Adjusts for the TCLK format and cycle span
+    # Assumes caller will drive pattern to tester
+    # via .drive or similar
+    def tclk_cycle
+      case @tclk_format
+        when :rh
+          tclk_val = 0
+        when :rl
+          tclk_val = 1
+        else
+          fail 'ERROR: Invalid Tclk timing format!'
+      end
+
+      # determine whether to mask TDO on first half cycle
+      mask_tdo_half0 =  ((@tclk_format == :rl) && (@tdo_strobe == :tclk_low) && (@tclk_multiple > 1)) ||
+                        ((@tclk_format == :rh) && (@tdo_strobe == :tclk_high) && (@tclk_multiple > 1))
+
+      # determine whether to mask TDO on second half cycle
+      mask_tdo_half1 =  ((@tclk_format == :rl) && (@tdo_strobe == :tclk_high) && (@tclk_multiple > 1)) ||
+                        ((@tclk_format == :rh) && (@tdo_strobe == :tclk_low) && (@tclk_multiple > 1))
+
+      # determine whether TDO is set to capture for this TCK cycle
+      tdo_to_be_captured = owner.pin(:tdo).to_be_captured?
+
+      # If TDO is already suspended (by an application) then don't do the
+      # suspends below since the resume will clear the application's suspend
+      tdo_already_suspended = owner.pin(:tdo).suspended? && !@tdo_suspended_by_driver
+
+      @tclk_multiple.times do |i|
+        # 50% duty cycle if @tclk_multiple is even, otherwise slightly off
+
+        if tdo_to_be_captured
+          owner.pin(:tdo).state = @tdo_store_cycle == i ? :capture : :dont_care
+        end
+
+        if i < (@tclk_multiple + 1) / 2
+          # first half of cycle
+          owner.pin(:tclk).drive(tclk_val)
+          unless tdo_already_suspended
+            unless tdo_to_be_captured
+              if mask_tdo_half0
+                @tdo_suspended_by_driver = true
+                owner.pin(:tdo).suspend
+              else
+                @tdo_suspended_by_driver = false
+                owner.pin(:tdo).resume
+              end
+            end
+          end
+        else
+          # second half of cycle
+          owner.pin(:tclk).drive(1 - tclk_val)
+          unless tdo_already_suspended
+            unless tdo_to_be_captured
+              if mask_tdo_half1
+                @tdo_suspended_by_driver = true
+                owner.pin(:tdo).suspend
+              else
+                @tdo_suspended_by_driver = false
+                owner.pin(:tdo).resume
+              end
+            end
+          end
+        end
+        yield
+      end
+      if @tdo_suspended_by_driver
+        owner.pin(:tdo).resume
+        @tdo_suspended_by_driver = false
+      end
+    end
+
+    # Applies the given value to the TMS pin and then
+    # cycles the tester for one TCLK
+    #
+    # @param [Integer] val Value to drive on the TMS pin, 0 or 1
+    def tms!(val)
+      if @deferred_compare
+        @deferred_compare = nil
+      else
+        owner.pin(:tdo).dont_care
+      end
+
+      tclk_cycle do
+        owner.pin(:tms).drive!(val)
+      end
+    end
+
+    # Write the given value, register or bit collection to the data register.
+    # This is a self contained method that will take care of the TAP controller
+    # state transitions, exiting with the TAP controller in Run-Test/Idle.
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be written. If a reg/bit collection is supplied this can be pre-marked for overlay.
+    # @param [Hash] options Options to customize the operation
+    # @option options [Integer] :size The number of bits to write. This is optional
+    #   when supplying a register or bit collection in which case the size will be derived from
+    #   the number of bits supplied. If this option is supplied then it will override
+    #   the size derived from the bits. If the size is greater than the number of bits
+    #   provided then the additional space will be padded by 0s.
+    # @option options [String] :msg  By default will not make any comments directly here.  Can pass
+    #   a msg to be written out prior to shifting data.
+    def write_dr(reg_or_val, options = {})
+      if Origen.tester.respond_to?(:write_dr)
+        Origen.tester.write_dr(reg_or_val, options)
+      else
+        if options[:msg]
+          cc "#{options[:msg]}\n"
+        end
+        shift_dr do
+          if options[:overlay] == true
+            $tester.label(options[:overlay_label], true) # apply global label
+          end
+          shift(reg_or_val, options)
+        end
+      end
+    end
+
+    # Read the given value, register or bit collection from the data register.
+    # This is a self contained method that will take care of the TAP controller
+    # state transitions, exiting with the TAP controller in Run-Test/Idle.
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be read. If a reg/bit collection is supplied this can be pre-marked for read in which
+    #   case only the marked bits will be read and the vectors corresponding to the data from the non-read
+    #   bits will be set to don't care. Similarly the bits can be pre-marked for store (capture) or
+    #   overlay.
+    # @param [Hash] options Options to customize the operation
+    # @option options [Integer] :size The number of bits to read. This is optional
+    #   when supplying a register or bit collection in which case the size will be derived from
+    #   the number of bits supplied. If the size is supplied then it will override
+    #   the size derived from the bits. If the size is greater than the number of bits
+    #   provided then the additional space will be padded by don't care cycles.
+    # @option options [String] :msg  By default will not make any comments directly here.  Can pass
+    #   a msg to be written out prior to shifting data.
+    def read_dr(reg_or_val, options = {})
+      if Origen.tester.respond_to?(:read_dr)
+        Origen.tester.read_dr(reg_or_val, options)
+      else
+        options = {
+          read: true
+        }.merge(options)
+        if options[:msg]
+          cc "#{options[:msg]}\n"
+        end
+        shift_dr do
+          if options[:overlay] == true
+            $tester.label(options[:overlay_label], true) # apply global label
+          end
+          shift(reg_or_val, options)
+        end
+      end
+    end
+
+    # Write the given value, register or bit collection to the instruction register.
+    # This is a self contained method that will take care of the TAP controller
+    # state transitions, exiting with the TAP controller in Run-Test/Idle.
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be written. If a reg/bit collection is supplied this can be pre-marked for overlay.
+    # @param [Hash] options Options to customize the operation
+    # @option options [Integer] :size The number of bits to write. This is optional
+    #   when supplying a register or bit collection in which case the size will be derived from
+    #   the number of bits supplied. If this option is supplied then it will override
+    #   the size derived from the bits. If the size is greater than the number of bits
+    #   provided then the additional space will be padded by 0s.
+    # @option options [Boolean] :force By default multiple calls to this method will not generate
+    #   multiple writes. This is to allow wrapper algorithms to remain efficient yet not have to
+    #   manually track the IR state (and in many cases this may be impossible due to multiple
+    #   protocols using the same JTAG). To force a write regardless of what the driver thinks the IR
+    #   contains set this to true.
+    # @option options [String] :msg  By default will not make any comments directly here.  Can pass
+    #   a msg to be written out prior to shifting in IR data.  Will not write comment only if write
+    #   occurs.
+    def write_ir(reg_or_val, options = {})
+      if Origen.tester.respond_to?(:write_ir)
+        Origen.tester.write_ir(reg_or_val, options)
+      else
+        val = reg_or_val.respond_to?(:data) ? reg_or_val.data : reg_or_val
+        if val != ir_value || options[:force]
+          if options[:msg]
+            cc "#{options[:msg]}\n"
+          end
+          shift_ir do
+            shift(reg_or_val, options)
+          end
+          @ir_value = val
+        end
+      end
+    end
+
+    # Read the given value, register or bit collection from the instruction register.
+    # This is a self contained method that will take care of the TAP controller
+    # state transitions, exiting with the TAP controller in Run-Test/Idle.
+    #
+    # @param [Integer, Origen::Register::Reg, Origen::Register::BitCollection, Origen::Register::Bit] reg_or_val
+    #   Value to be read. If a reg/bit collection is supplied this can be pre-marked for read in which
+    #   case only the marked bits will be read and the vectors corresponding to the data from the non-read
+    #   bits will be set to don't care. Similarly the bits can be pre-marked for store (capture) or
+    #   overlay.
+    # @param [Hash] options Options to customize the operation
+    # @option options [Integer] :size The number of bits to read. This is optional
+    #   when supplying a register or bit collection in which case the size will be derived from
+    #   the number of bits supplied. If the size is supplied then it will override
+    #   the size derived from the bits. If the size is greater than the number of bits
+    #   provided then the additional space will be padded by don't care cycles.
+    # @option options [String] :msg  By default will not make any comments directly here.  Can pass
+    #   a msg to be written out prior to shifting data.
+    def read_ir(reg_or_val, options = {})
+      if Origen.tester.respond_to?(:read_ir)
+        Origen.tester.read_ir(reg_or_val, options)
+      else
+        options = {
+          read: true
+        }.merge(options)
+        if options[:msg]
+          cc "#{options[:msg]}\n"
+        end
+        shift_ir do
+          shift(reg_or_val, options)
+        end
+      end
+    end
+
+    private
+
+    def extract_size(reg_or_val, options = {})
+      size = options[:size]
+      unless size
+        if reg_or_val.is_a?(Fixnum) || !reg_or_val.respond_to?(:size)
+          fail 'When suppling a value to JTAG::Driver#shift you must supply a :size in the options!'
+        else
+          size = reg_or_val.size
+        end
+      end
+      size
+    end
+
+    # Validates that the parent object (the owner) has defined the necessary
+    # pins to implement the JTAG
+    def validate_pins
+      REQUIRED_PINS.each do |name|
+        owner.pin(name)
+      end
+    rescue
+      puts 'Missing JTAG pins!'
+      puts "In order to use the JTAG driver your #{owner.class} class must define"
+      puts 'the following pins (an alias is fine):'
+      puts REQUIRED_PINS
+      raise 'JTAG driver error!'
+    end
+  end
+end