diff --git a/src/isolator/hei_isolator.cpp b/src/isolator/hei_isolator.cpp
index cbb6652..1ff52a4 100644
--- a/src/isolator/hei_isolator.cpp
+++ b/src/isolator/hei_isolator.cpp
@@ -1,5 +1,6 @@
 
 #include <isolator/hei_isolator.hpp>
+#include <register/hei_hardware_register.hpp>
 
 namespace libhei
 {
@@ -32,13 +33,22 @@
     // Flush the isolation data to ensure a clean slate.
     o_isoData.clear();
 
-    // BEGIN temporary code
+    // Analyze active error on each chip.
     for ( auto const & chip : i_chipList )
     {
+        // In order to access hardware, we must tell the HardwareRegisters which
+        // chip to access.
+        HardwareRegister::setAccessor( chip );
+
+        // BEGIN temporary code
         HEI_INF( "Isolator::isolate(%p,%u)", chip.getChip(),
                  chip.getType() );
+        // END temporary code
+
+        // Clean up the hardware accessor chip to prevent accidental hardware
+        // access.
+        HardwareRegister::clearAccessor();
     }
-    // END temporary code
 
     return rc;
 }
diff --git a/src/register/hei_hardware_register.cpp b/src/register/hei_hardware_register.cpp
index 177bbd0..5663f3b 100755
--- a/src/register/hei_hardware_register.cpp
+++ b/src/register/hei_hardware_register.cpp
@@ -10,6 +10,7 @@
 //----------------------------------------------------------------------
 
 #include <hei_includes.hpp>
+#include <hei_user_interface.hpp>
 #include <register/hei_hardware_register.hpp>
 #include <util/hei_bit_string.hpp>
 
@@ -18,7 +19,6 @@
 #include <prdfMain.H>
 #include <prdfRasServices.H>
 #include <prdfRegisterCache.H>
-#include <prdfHomRegisterAccess.H>
 #include <prdfPlatServices.H>
 #include <prdfExtensibleChip.H>
 
@@ -96,128 +96,96 @@
 
     return readCache();
 }
+#endif
 
 //------------------------------------------------------------------------------
 
-uint32_t HardwareRegister::Read() const
+ReturnCode HardwareRegister::read( bool i_force ) const
 {
-    uint32_t o_rc = SUCCESS;
+    ReturnCode rc;
 
-    // First query the cache for an existing entry.
-    if ( !queryCache() )
+#if 0
+    // Read from hardware only if the read is forced or the entry for this
+    // instance does not exist in the cache.
+    if ( i_force || !queryCache() )
     {
-        // There was not a previous entry in the cache, so do a ForceRead() to
-        // sync the cache with hardware.
-        o_rc = ForceRead();
+        // This register must be readable.
+        HEI_ASSERT( ( ACCESS_NONE != iv_operationType ) &&
+                    ( ACCESS_WO   != iv_operationType ) );
+
+        // Get the buffer from the register cache.
+        BitString & bs = readCache();
+
+        // Get the byte size of the buffer.
+        size_t sz_buffer = BitString::getMinBytes( bs.getBitLen() );
+
+        // Read this register from hardware.
+        rc = registerRead( getAccessorChip().getChip(), bs.getBufAddr(),
+                           sz_buffer, getRegisterType(), getAddress() );
+        if ( RC_SUCCESS != rc )
+        {
+            // The read failed and we can't trust what was put in the register
+            // cache. So remove this instance's entry from the cache.
+            flushCache( getAccessorChip() );
+        }
+        else
+        {
+            // Sanity check. The returned size of the data written to the buffer
+            // should match the register size.
+            HEI_ASSERT( getSize() == sz_buffer );
+        }
     }
+#endif
 
-    return o_rc;
+    return rc;
 }
 
 //------------------------------------------------------------------------------
 
-uint32_t HardwareRegister::ForceRead() const
+#ifndef __HEI_READ_ONLY
+
+ReturnCode HardwareRegister::write() const
 {
-    #define PRDF_FUNC "[HardwareRegister::ForceRead] "
+    ReturnCode rc;
 
-    uint32_t o_rc = FAIL;
+#if 0
+    // This register must be writable.
+    HEI_ASSERT( ( ACCESS_NONE != iv_operationType ) &&
+                ( ACCESS_RO   != iv_operationType ) );
 
-    do
+    // An entry for this register must exist in the cache.
+    HEI_ASSERT( queryCache() );
+
+    // Get the buffer from the register cache.
+    BitString & bs = readCache();
+
+    // Get the byte size of the buffer.
+    size_t sz_buffer = BitString::getMinBytes( bs.getBitLen() );
+
+    // Write to this register to hardware.
+    rc = registerWrite( getAccessorChip().getChip(), bs.getBufAddr(),
+                        sz_buffer, getRegisterType(), getAddress() );
+
+    if ( RC_SUCCESS == rc )
     {
-        // No read allowed if register access attribute is write-only or no
-        // access.
-        if ( ( ACCESS_NONE == iv_operationType ) &&
-                ( ACCESS_WO == iv_operationType ) )
-        {
-            HEI_ERR( PRDF_FUNC "Write-only register: 0x%08x 0x%016llx",
-                      getChip()->GetId(), iv_scomAddress );
-            break;
-        }
+        // Sanity check. The returned size of the data written to the buffer
+        // should match the register size.
+        HEI_ASSERT( getSize() == sz_buffer );
+    }
+#endif
 
-        // Read hardware.
-        o_rc = Access( readCache(), RegisterAccess::READ );
-        if ( SUCCESS != o_rc )
-        {
-            // The read failed. Remove the entry from the cache so a subsequent
-            // Read() will attempt to read from hardware again.
-            flushCache( getChip() );
-        }
-
-    } while (0);
-
-    return o_rc;
-
-    #undef PRDF_FUNC
+    return rc;
 }
 
-//------------------------------------------------------------------------------
+#endif // __HEI_READ_ONLY
 
-uint32_t HardwareRegister::Write()
-{
-    #define PRDF_FUNC "[HardwareRegister::Write] "
-
-    uint32_t o_rc = FAIL;
-
-    do
-    {
-        // No write allowed if register access attribute is read-only or no
-        // access.
-        if ( ( ACCESS_NONE == iv_operationType ) &&
-                 ( ACCESS_RO == iv_operationType ) )
-        {
-            HEI_ERR( PRDF_FUNC "Read-only register: 0x%08x 0x%016llx",
-                      getChip()->GetId(), iv_scomAddress );
-            break;
-        }
-
-        // Query the cache for an existing entry.
-        if ( !queryCache() )
-        {
-            // Something bad happened and there was nothing in the cache to
-            // write to hardware.
-            HEI_ERR( PRDF_FUNC "No entry found in cache: 0x%08x 0x%016llx",
-                      getChip()->GetId(), iv_scomAddress );
-            break;
-        }
-
-        // Write hardware.
-        o_rc = Access( readCache(), RegisterAccess::WRITE );
-
-    } while (0);
-
-    return o_rc;
-
-    #undef PRDF_FUNC
-}
-
-//------------------------------------------------------------------------------
-
-uint32_t HardwareRegister::Access( BitString & bs,
-                               RegisterAccess::Operation op ) const
-{
-    int32_t l_rc = SCR_ACCESS_FAILED;
-    TARGETING::TargetHandle_t i_pchipTarget = getChip()->GetChipHandle();
-    l_rc = getScomService().Access( i_pchipTarget,bs,iv_scomAddress,op );
-
-    return(l_rc);
-}
-//-----------------------------------------------------------------------------
-ExtensibleChip* HardwareRegister::getChip( )const
-{
-    ExtensibleChip* l_pchip = nullptr;
-    l_pchip = ServiceDataCollector::getChipAnalyzed();
-    TARGETING::TYPE l_type = PlatServices::getTargetType(
-                                                l_pchip->GetChipHandle() );
-    HEI_ASSERT( iv_chipType == l_type )
-    return l_pchip;
-}
-
+#if 0
 //------------------------------------------------------------------------------
 
 bool HardwareRegister::queryCache() const
 {
     RegDataCache & cache = RegDataCache::getCachedRegisters();
-    BitString * bs = cache.queryCache( getChip(), this );
+    BitString * bs = cache.queryCache( getAccessorChip(), this );
     return ( nullptr != bs );
 }
 
@@ -226,7 +194,7 @@
 BitString & HardwareRegister::readCache() const
 {
     RegDataCache & cache = RegDataCache::getCachedRegisters();
-    return cache.read( getChip(), this );
+    return cache.read( getAccessorChip(), this );
 }
 
 //------------------------------------------------------------------------------
@@ -280,5 +248,11 @@
 }
 #endif
 
+//------------------------------------------------------------------------------
+
+HardwareRegister::Accessor * HardwareRegister::cv_accessor = nullptr;
+
+//------------------------------------------------------------------------------
+
 } // end namespace libhei
 
diff --git a/src/register/hei_hardware_register.hpp b/src/register/hei_hardware_register.hpp
index c6722fb..066f6db 100755
--- a/src/register/hei_hardware_register.hpp
+++ b/src/register/hei_hardware_register.hpp
@@ -14,10 +14,6 @@
 #include <register/hei_register.hpp>
 #include <util/hei_bit_string.hpp>
 
-#if 0
-#include <prdfHomRegisterAccess.H>
-#endif
-
 namespace libhei
 {
 
@@ -28,11 +24,28 @@
 class ExtensibleChip;
 #endif
 
+/**
+ * @brief Stores information (e.g. address, type, length, etc.) for an actual
+ *        hardware register.
+ *
+ * Hardware access:
+ *
+ *  Actual hardware access is defined by the user application via the user
+ *  interface APIs. In order to tell the user application which chip to target,
+ *  the user application gives the isolator pointers to its chip objects. As
+ *  each chip needs to be accessed, the isolator must store the chip in a
+ *  static variable defined in this class. The intended use is:
+ *
+ *   - Call HardwareRegister::setAccessor() with the target chip.
+ *   - Perform all necessary hardware accesses to that chip.
+ *   - Call HardwareRegister::clearAccessor() to remove the chip access. This
+ *     helps ensure we don't try to access the wrong chip.
+ */
 class HardwareRegister : public Register
 {
-#if 0
   public:
 
+#if 0
     /**
      * @brief     constructor
      * @param     i_address        address of the register
@@ -81,26 +94,31 @@
      * @return    length of bit string
      */
     uint32_t GetBitLength(void) const { return iv_bitLength ;}
+#endif
 
     /**
-     * @brief     Directly reads from hardware register
-     * @return    SUCCESS|FAIL
+     * @brief  Reads a register from hardware via the user interface APIs.
+     * @param  i_force When false, this function will only read from hardware if
+     *                 an entry for this instance does not already exist in the
+     *                 register cache. When true, the entry in the register
+     *                 cache is flushed, if it exists. Then this function will
+     *                 read from hardware and update the cache.
+     * @return See the return code from the registerRead() user interface API.
      */
-    virtual uint32_t ForceRead() const;
+    ReturnCode read( bool i_force = false ) const;
+
+    #ifndef __HEI_READ_ONLY
 
     /**
-     * @brief     Returns contents of register.If entry does not exist in cache
-     *            a  fresh entry is created and hardware is read.
-     * @return    SUCCESS|FAIL
-    */
-    virtual uint32_t Read() const;
-
-    /**
-     * @brief     Writes cache contents to register.
-     * @return    SUCCESS|FAIL
+     * @brief  Writes the value stored in the register cache to hardware via the
+     *         user interface APIs.
+     * @return See the return code from the registerWrite() user interface API.
      */
-    virtual uint32_t Write();
+    ReturnCode write() const;
 
+    #endif // __HEI_READ_ONLY
+
+#if 0
     /**
      * @brief     Returns the hash id of register
      * @return    returns  hash id of register
@@ -173,21 +191,6 @@
     * @return   Refer to function description
    */
     virtual BitString & AccessBitString( );
-    /**
-     * @brief     Gets the register read and write done by calling access
-     *            function of scom  accessor service.
-     * @param     reference to bit string maintained in caller  class
-     * @param     Read or write operation
-     * @return    [SUCCESS|FAIL]
-     */
-    uint32_t Access( BitString & bs,
-                     RegisterAccess::Operation op )const;
-
-    /**
-     * @brief  Returns rulechip pointer associated with the register
-     * @return Refer to function description
-     */
-    virtual ExtensibleChip * getChip() const;
 
 private: // functions
 
@@ -218,6 +221,90 @@
     AccessLevel     iv_operationType; // Operation supported (RO, WO, or RW)
 
 #endif
+
+  private: // Hardware accessor class variable
+
+    /** @brief A simple class that stores the chip used to access hardware. */
+    class Accessor
+    {
+      public:
+
+        /**
+         * @brief Constructor.
+         * @param i_chip The chip used to access hardware.
+         */
+        explicit Accessor( const Chip & i_chip ) :
+            iv_chip( i_chip )
+        {}
+
+        /** @brief Destructor. */
+        ~Accessor() = default;
+
+        /** @brief Copy constructor. */
+        Accessor( const Accessor & ) = delete;
+
+        /** @brief Assignment operator. */
+        Accessor & operator=( const Accessor & ) = delete;
+
+        /** @return The chip used to access hardware. */
+        const Chip & getChip() const { return iv_chip; }
+
+      private:
+
+        /**
+         * A Chip object provided by the user application. The isolator does not
+         * know anything about this object nor how to use it. Its only purpose
+         * is to get passed back to the user application for hardware access
+         * operations.
+         */
+        const Chip iv_chip;
+
+    }; // end class Accessor
+
+    /**
+     * This allows all HardwareRegister objects access to a chip via the user
+     * interface APIs. It is intentially defined as a pointer. It can be set to
+     * nullptr to signify that access is restricted at this time. This is useful
+     * to prevent users from accidentally accessing registers on the wrong chip.
+     * It is recommended to use setAccessor() and clearAccessor() to manage this
+     * variable.
+     */
+    static Accessor * cv_accessor;
+
+  public: // Hardware accessor management functions.
+
+    /**
+     * @brief Initializes a new hardware accessor.
+     * @param i_chip The chip used to access hardware.
+     */
+    static void setAccessor( const Chip & i_chip )
+    {
+        clearAccessor();
+        cv_accessor = new Accessor( i_chip );
+    }
+
+    /** @brief Deletes the current hardware accessor. */
+    static void clearAccessor()
+    {
+        delete cv_accessor;
+        cv_accessor = nullptr;
+    }
+
+  private: // Hardware accessor management functions.
+
+    /** @return The chip stored in cv_accessor. */
+    const Chip & getAccessorChip() const
+    {
+        HEI_ASSERT( nullptr != cv_accessor );
+
+#if 0
+        // Extra sanity check to verify this register belongs on the target
+        // accessor chip.
+        HEI_ASSERT( getChipType() != cv_accessor->getChip().getChipType() );
+#endif
+
+        return cv_accessor->getChip();
+    }
 };
 
 } // end namespace libhei
diff --git a/src/register/prdfCaptureData.C b/src/register/prdfCaptureData.C
index 7dac116..190de9d 100755
--- a/src/register/prdfCaptureData.C
+++ b/src/register/prdfCaptureData.C
@@ -34,7 +34,6 @@
 #include <register/hei_hardware_register.hpp>
 #include <util/hei_bit_string.hpp>
 
-#include <prdfHomRegisterAccess.H>  // dg06a
 #include <iipchip.h>
 #include <iipCaptureData.h>
 #include <string.h>
diff --git a/src/register/prdfHomRegisterAccess.C b/src/register/prdfHomRegisterAccess.C
deleted file mode 100755
index b1702bb..0000000
--- a/src/register/prdfHomRegisterAccess.C
+++ /dev/null
@@ -1,224 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/diag/prdf/common/framework/register/prdfHomRegisterAccess.C $ */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2017                        */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-
-/**
-  @file prdfHomRegisterAccess.C
-  @brief definition of HomRegisterAccess
-*/
-//----------------------------------------------------------------------
-//  Includes
-//----------------------------------------------------------------------
-
-#include <hei_includes.hpp>
-#include <util/hei_bit_string.hpp>
-
-#include <prdfHomRegisterAccess.H>
-#include <prdf_service_codes.H>
-#include <prdfMain.H>
-#include <prdfPlatServices.H>
-#include <prdfGlobal.H>
-#include <prdfErrlUtil.H>
-
-#ifdef __HOSTBOOT_RUNTIME
-#include <pm_common_ext.H>
-#include <p9_stop_api.H>
-#endif
-
-using namespace TARGETING;
-
-namespace libhei
-{
-
-//----------------------------------------------------------------------
-//  User Types
-//----------------------------------------------------------------------
-
-//----------------------------------------------------------------------
-//  Constants
-//----------------------------------------------------------------------
-
-//----------------------------------------------------------------------
-//  Macros
-//----------------------------------------------------------------------
-
-//----------------------------------------------------------------------
-//  Internal Function Prototypes
-//----------------------------------------------------------------------
-
-//----------------------------------------------------------------------
-//  Global Variables
-//----------------------------------------------------------------------
-
-//------------------------------------------------------------------------------
-// Member Function Specifications
-//------------------------------------------------------------------------------
-
-ScomService& getScomService()
-{
-    return PRDF_GET_SINGLETON(theScomService);
-}
-
-ScomService::ScomService() :
-    iv_ScomAccessor(nullptr)
-{
-    PRDF_DTRAC("ScomService() initializing default iv_ScomAccessor");
-    iv_ScomAccessor = new ScomAccessor();
-}
-
-ScomService::~ScomService()
-{
-    if(nullptr != iv_ScomAccessor)
-    {
-        PRDF_DTRAC("~ScomService() deleting iv_ScomAccessor");
-        delete iv_ScomAccessor;
-        iv_ScomAccessor = nullptr;
-    }
-}
-
-void ScomService::setScomAccessor(ScomAccessor & i_ScomAccessor)
-{
-    PRDF_DTRAC("ScomService::setScomAccessor() setting new scom accessor");
-
-    if(nullptr != iv_ScomAccessor)
-    {
-        PRDF_TRAC("ScomService::setScomAccessor() deleting old iv_ScomAccessor");
-        delete iv_ScomAccessor;
-        iv_ScomAccessor = nullptr;
-    }
-
-    iv_ScomAccessor = &i_ScomAccessor;
-}
-
-uint32_t ScomService::Access(TargetHandle_t i_target,
-                             BitString & bs,
-                             uint64_t registerId,
-                             RegisterAccess::Operation operation) const
-{
-    PRDF_DENTER("ScomService::Access()");
-    uint32_t rc = SUCCESS;
-
-    rc = iv_ScomAccessor->Access( i_target,
-                                  bs,
-                                  registerId,
-                                  operation);
-
-    PRDF_DEXIT("ScomService::Access(): rc=%d", rc);
-
-    return rc;
-}
-
-
-uint32_t ScomAccessor::Access(TargetHandle_t i_target,
-                                BitString & bs,
-                                uint64_t registerId,
-                                RegisterAccess::Operation operation) const
-{
-    PRDF_DENTER("ScomAccessor::Access()");
-
-    uint32_t rc = SUCCESS;
-
-    if(i_target != nullptr)
-    {
-        switch (operation)
-        {
-            case RegisterAccess::WRITE:
-            {
-                rc = PRDF::PlatServices::putScom(i_target, bs, registerId);
-
-                #ifdef __HOSTBOOT_RUNTIME
-                using namespace stopImageSection;
-
-                // Update CORE/EQ/EX Fir masks in HCODE image
-                TARGETING::TYPE type = PlatServices::getTargetType(i_target);
-                if( TYPE_EX == type || TYPE_EQ == type || TYPE_CORE == type )
-                {
-                    uint32_t l_MaskReg[7] = {
-                                        0x2004000f,   // EC_LFIR_MASK_OR
-                                        0x20010a45,   // EC_COREFIR_MASK_OR
-                                        0x1004000f,   // EQ_LOCAL_FIR_MASK_OR
-                                        0x10010805,   // EX_L2FIR_MASK_OR
-                                        0x10011005,   // EX_NCUFIR_MASK_OR
-                                        0x10011805,   // EX_L3FIR_MASK_OR
-                                        0x10012005 }; // EX_CMEFIR_MASK_OR
-
-                    for(uint32_t l_count = 0; l_count < 7; l_count++)
-                    {
-                        if( l_MaskReg[l_count]  == registerId )
-                        {
-                            errlHndl_t err = nullptr;
-                            uint32_t sec = (TYPE_CORE == type) ?
-                                P9_STOP_SECTION_CORE_SCOM :
-                                P9_STOP_SECTION_EQ_SCOM;
-
-                            uint64_t scomVal =
-                                (((uint64_t)bs.getFieldJustify(0, 32)) << 32) |
-                                 ((uint64_t)bs.getFieldJustify(32, 32));
-
-                            err = RTPM::hcode_update(sec,
-                                                     P9_STOP_SCOM_OR_APPEND,
-                                                     i_target,
-                                                     registerId,
-                                                     scomVal);
-                            if( nullptr != err)
-                            {
-                                HEI_ERR("[ScomAccessor::Access()] Error in"
-                                         " hcode_update");
-                                PRDF_COMMIT_ERRL( err, ERRL_ACTION_REPORT );
-                            }
-                            break;
-                        }
-                    }
-                }
-                #endif
-                break;
-            }
-
-            case RegisterAccess::READ:
-                bs.clearAll(); // clear all bits
-
-                rc = PRDF::PlatServices::getScom(i_target, bs, registerId);
-
-                break;
-
-            default:
-                HEI_ERR("ScomAccessor::Access() unsuppported scom op: 0x%08X",
-                          operation);
-                break;
-
-        } // end switch operation
-
-    }
-    else // Invalid target
-    {
-        rc = PRD_SCANCOM_FAILURE;
-    }
-
-    PRDF_DEXIT("ScomAccessor::Access()");
-
-    return rc;
-}
-
-} // end namespace libhei
-
diff --git a/src/register/prdfHomRegisterAccess.H b/src/register/prdfHomRegisterAccess.H
deleted file mode 100755
index d382048..0000000
--- a/src/register/prdfHomRegisterAccess.H
+++ /dev/null
@@ -1,167 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/diag/prdf/common/framework/register/prdfHomRegisterAccess.H $ */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2017                        */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-
-#ifndef PRDFHOMREGISTERACCESS_H
-#define PRDFHOMREGISTERACCESS_H
-/**
-   @file prdfHomRegisterAccess.H
-   @brief Provide access to scan & scan com registers via the HOM
-*/
-
-
-//--------------------------------------------------------------------
-// Includes
-//--------------------------------------------------------------------
-
-#include <vector>
-#include <prdfPlatServices.H>
-#include <prdfErrlUtil.H>
-#include <prdfGlobal.H>
-//--------------------------------------------------------------------
-//  Forward References
-//--------------------------------------------------------------------
-
-namespace libhei
-{
-
-namespace RegisterAccess
-{
-    enum Operation
-    {
-        READ  = 0,
-        WRITE = 1,
-    };
-}
-
-class ScomAccessor
-{
-  public:
-
-    /**
-     * @brief ctor
-     */
-    inline ScomAccessor() {}
-
-    /**
-     * @brief dtor
-     */
-    inline virtual ~ScomAccessor() {}
-
-    /**
-     * @brief Access the scan com register
-     * @param i_target    Target to access the register
-     * @param bs holds    data read or to write
-     * @param registerId  register address
-     * @param operation   [READ|WRITE]
-     * @returns SUCCESS or PRD_SCANCOM_FAILURE
-     * @pre bs.Length() must be size of register data to read/write
-     * @post For read operation, bs is modified to reflect hardware
-     *       register state
-     */
-    virtual uint32_t Access( TARGETING::TargetHandle_t i_target,
-                             BitString & bs,
-                             uint64_t registerId,
-                             RegisterAccess::Operation operation) const;
-
-  private:
-
-    /**
-     * @brief disable copy
-     */
-    ScomAccessor(const ScomAccessor &);
-
-    /**
-     * @brief disable assignment
-     */
-    ScomAccessor & operator=(const ScomAccessor &);
-
-};
-
-/**
- *  @brief Singleton to access the only ScomService
- */
-class ScomService;
-PRDF_DECLARE_SINGLETON(ScomService, theScomService);
-
-/**
- *  @brief Returns a reference to the ScomService singleton
- *
- *  @return Reference to the ScomService
- */
-ScomService& getScomService();
-
-/**
- *  @brief ScomService class
- */
-class ScomService
-{
-  public:
-
-    /**
-     *  @brief Construct ScomService
-     */
-    ScomService();
-
-    /**
-     *  @brief Destroys ScomService
-     */
-    ~ScomService();
-
-    /**
-     * @brief set the scom accessor to be used
-     *
-     * @param[in] i_ScomAccessor new scom accessor
-     */
-    void setScomAccessor(ScomAccessor & i_ScomAccessor);
-
-    /**
-     Access the scan com register
-     @param i_target Target to access the register
-     @param BitString - holds data read or to write
-     @param register address
-     @param [READ|WRITE]
-     @returns [SUCCESS|FAIL]
-     @pre bs.Length() must be size of register data to read/write
-     @post For read operation, bs is modified to reflect hardware register state
-     @note
-     */
-    virtual uint32_t Access(TARGETING::TargetHandle_t i_target,
-                            BitString & bs,
-                            uint64_t registerId,
-                            RegisterAccess::Operation operation) const;
-
-  private:
-
-    // Disable copy constructor / assignment operator
-    ScomService(const ScomService& i_right);
-    ScomService& operator=(const ScomService& i_right);
-
-    // Scom access to actual HW or Sim
-    ScomAccessor * iv_ScomAccessor;
-};
-
-} // end namespace libhei
-
-#endif /* PRDFHOMREGISTERACCESS_H */
diff --git a/src/register/prdfRegisterCache.H b/src/register/prdfRegisterCache.H
index 8ef5159..9176b0e 100644
--- a/src/register/prdfRegisterCache.H
+++ b/src/register/prdfRegisterCache.H
@@ -34,7 +34,6 @@
 
 #include <prdfGlobal.H>
 #include <prdfScanFacility.H>
-#include <prdfScomRegisterAccess.H>
 #include <prdfTargetFwdRef.H>
 
 namespace libhei
diff --git a/src/register/prdfScanFacility.C b/src/register/prdfScanFacility.C
index 2ce591d..a0aadac 100755
--- a/src/register/prdfScanFacility.C
+++ b/src/register/prdfScanFacility.C
@@ -36,7 +36,6 @@
 #include <prdfScanFacility.H>
 #include <prdfFlyWeight.C>
 #include <prdfFlyWeightS.C>
-#include <prdfScomRegisterAccess.H>
 
 namespace libhei
 {
diff --git a/src/register/prdfScanFacility.H b/src/register/prdfScanFacility.H
index 4107c83..501f72b 100755
--- a/src/register/prdfScanFacility.H
+++ b/src/register/prdfScanFacility.H
@@ -41,8 +41,6 @@
 #include <prdfFlyWeight.H>
 #include <prdfFlyWeightS.H>
 #include <vector>
-#include <prdfHomRegisterAccess.H>
-#include <prdfScomRegisterAccess.H>
 #include <prdfPlatServices.H>
 
 namespace libhei
diff --git a/src/register/prdfScomRegisterAccess.C b/src/register/prdfScomRegisterAccess.C
deleted file mode 100644
index 3f3f271..0000000
--- a/src/register/prdfScomRegisterAccess.C
+++ /dev/null
@@ -1,86 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/diag/prdf/common/framework/register/prdfScomRegisterAccess.C $ */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2012,2014              */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-
-#include <prdfScomRegisterAccess.H>
-#include <prdfScanFacility.H>
-#include <prdfRegisterCache.H>
-#include <prdfExtensibleChip.H>
-
-namespace libhei
-{
-
-ScomRegisterAccess::ScomRegisterAccess(
-                    const Register & i_pRegister,
-                    ExtensibleChip * i_pRuleChip ) :
-    HardwareRegister( i_pRegister ),
-    iv_containerChip( i_pRuleChip )
-{}
-
-//----------------------------------------------------------------------
-
-ExtensibleChip* ScomRegisterAccess::getChip( )const
-{
-    return iv_containerChip;
-}
-
-//----------------------------------------------------------------------
-
-bool ScomRegisterAccess::operator == (
-                const ScomRegisterAccess & i_rightRegister ) const
-{
-    if( GetAddress() == i_rightRegister.GetAddress() )
-    {
-        return ( getChip() == i_rightRegister.getChip() );
-    }
-    else
-    {
-        return false ;
-    }
-
-}
-//----------------------------------------------------------------------
-
-bool ScomRegisterAccess::operator < (
-                const ScomRegisterAccess & i_rightRegister ) const
-{
-    if( GetAddress() == i_rightRegister.GetAddress() )
-    {
-        return ( getChip() < i_rightRegister.getChip() );
-    }
-    else
-    {
-        return ( GetAddress() < i_rightRegister.GetAddress() );
-    }
-}
-
-//----------------------------------------------------------------------
-bool ScomRegisterAccess::operator >= (
-                const ScomRegisterAccess & i_right ) const
-{
-    return !( *this < i_right );
-}
-
-//----------------------------------------------------------------------
-
-} // end namespace libhei
-
diff --git a/src/register/prdfScomRegisterAccess.H b/src/register/prdfScomRegisterAccess.H
deleted file mode 100644
index b99f8b6..0000000
--- a/src/register/prdfScomRegisterAccess.H
+++ /dev/null
@@ -1,111 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/usr/diag/prdf/common/framework/register/prdfScomRegisterAccess.H $ */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2012,2014              */
-/*                                                                        */
-/* Licensed under the Apache License, Version 2.0 (the "License");        */
-/* you may not use this file except in compliance with the License.       */
-/* You may obtain a copy of the License at                                */
-/*                                                                        */
-/*     http://www.apache.org/licenses/LICENSE-2.0                         */
-/*                                                                        */
-/* Unless required by applicable law or agreed to in writing, software    */
-/* distributed under the License is distributed on an "AS IS" BASIS,      */
-/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
-/* implied. See the License for the specific language governing           */
-/* permissions and limitations under the License.                         */
-/*                                                                        */
-/* IBM_PROLOG_END_TAG                                                     */
-
-#ifndef __PRDF_REGISTER_
-#define __PRDF_REGISTER_
-
-#include <register/hei_hardware_register.hpp>
-#include <util/hei_bit_string.hpp>
-
-#include <prdfPlatServices.H>
-
-/**
- * @brief Models register.This model of register has target info
- *
- * In order to reduce the register objects required by PRD to do attention
- * analysis, these are shared across all the  RuleChip objects associated with
- * target of same type.In order to realize this,target info is taken out of
- * register object .RuleChip contains target info.During Analysis ,pointer to
- * Rulechip under analysis is maintained in Service Data collector.During
- * register Read and Write,target info is obtained by register from service data
- * collector.This idea fails when getRegister is called for Register read and
- * write.It may be called from plugin code which may use a RuleChip different
- * from the one in SDC.We would like to avoid SDC getting updated from multiple
- * places.To simplify solution for this use case, a wrapper register is required
- * .This register model knows which rule chip it is associated with.When plugin
- * code calls getRegister ,instead of returning  targetless flyweight object,it
- * returns an object of class ScomRegisterAccess.Since register Read Write is
- * in parent class ,it's just a container for Rulechip pointer giving us a way
- * to do scom without having to look for associated target/rule chip somewhere
- * else.
- */
-
-namespace libhei
-{
-class ScomRegisterAccess : public HardwareRegister
-{
-    public :
-    /**
-     * @brief     constructor
-     * @param     i_Register     Reference to flyweight register
-     * @param     i_pchip        RuleChip associated with register
-     */
-    ScomRegisterAccess( const Register & i_Register,
-                        ExtensibleChip* i_pchip );
-    /**
-     * @brief     constructor
-     */
-    ScomRegisterAccess():HardwareRegister( ),iv_containerChip ( nullptr ){ };
-
-    /**
-     * @brief Destructor
-    */
-    ~ScomRegisterAccess(){ };
-    /**
-     * @brief     Returns pointer to rulechip associated with register
-     * @return    Returns rule chip pointer
-    */
-
-    virtual ExtensibleChip* getChip( ) const;
-    /**
-     * @brief     compares two ScomRegisterAccess register for equality
-     * @param     i_rightRegister   register to be compared against
-     * @return    Returns true if registers are equal false otherwise
-     */
-    bool operator == ( const ScomRegisterAccess & i_rightRegister ) const;
-    /**
-     * @brief     defines < operation for ScomRegisterAccess
-     * @param     i_rightRegister   register to be compared against
-     * @return    Returns false if i_rightRegisters is less and true otherwise
-     */
-    bool operator < ( const ScomRegisterAccess & i_rightRegister ) const;
-    /**
-     * @brief     defines >= operation for ScomRegisterAccess
-     * @param     i_right   register to be compared against
-     * @return    Returns true if registers is >= i_rightRegister false
-     *            otherwise
-     */
-    bool operator >= ( const ScomRegisterAccess & i_right ) const;
-
-
-    private://Data
-
-    ExtensibleChip* iv_containerChip;
-
-
-};
-
-} // end namespace libhei
-
-#endif
-