Interface to send processor voltage change requests to HWSV

This commit contains an altered implementation of hbVddrMsg that
is capable of sending voltage change requests related to the
processor to HWSV. It also contains the MRW parsing code
to retrieve processor I2C information and relay that data
to the FSP so POWR can actually change the voltage.

Change-Id: Ifcdbd9ebe0eb300a61ee17cc8be6751cee4ff228
Depends-on: I3a478e4a70421d73bcaf7c9746d6569192be4d10
RTC:158500
CMVC-Prereq: 1002713
CMVC-Prereq: 1005080
CMVC-Prereq: 1005149
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/28490
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>
Reviewed-by: Matt Derksen <v2cibmd@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

8 files changed, 450 insertions, 206 deletions

diff --git a/src/usr/isteps/istep13/hbVddrMsg.C b/src/usr/isteps/hbToHwsvVoltageMsg.C
index eb747925d..ab9d47029 100644
--- a/src/usr/isteps/istep13/hbVddrMsg.C
+++ b/src/usr/isteps/hbToHwsvVoltageMsg.C
@@ -1,12 +1,11 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: src/usr/isteps/istep13/hbVddrMsg.C $                          */
+/* $Source: src/usr/isteps/hbToHwsvVoltageMsg.C $                         */
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
 /* Contributors Listed Below - COPYRIGHT 2012,2016                        */
-/* [+] Google Inc.                                                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -34,13 +33,11 @@
 #include <trace/trace.H>
 #include <mbox/mbox_queues.H>
 #include <mbox/mboxif.H>
-
-#include "hbVddrMsg.H"
 #include <initservice/initserviceif.H>
 #include <pnor/pnorif.H>
-#include "platform_vddr.H"
-#include <istepHelperFuncs.H>
 #include <targeting/common/target.H>
+#include "hbToHwsvVoltageMsg.H"
+#include "istepHelperFuncs.H"
 
 
 using namespace ERRORLOG;
@@ -48,25 +45,25 @@ using namespace ERRORLOG;
 using namespace TARGETING;
 
 // Trace definition
-trace_desc_t* g_trac_volt = NULL;
-TRAC_INIT(&g_trac_volt, "HB_VDDR", 1024);
+trace_desc_t* g_trac_volt = nullptr;
+TRAC_INIT(&g_trac_volt, "HB_VOLT", 1024);
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::HBVddrMsg()
+// HBToHwsvVoltageMsg::HBToHwsvVoltageMsg()
 ///////////////////////////////////////////////////////////////////////////////
-HBVddrMsg::HBVddrMsg()
+HBToHwsvVoltageMsg::HBToHwsvVoltageMsg()
 {
-    TRACDCOMP( g_trac_volt, ENTER_MRK "HBVddrMsg::HBVddrMsg()" );
-    TRACDCOMP( g_trac_volt, EXIT_MRK "HBVddrMsg::HBVddrMsg()" );
+    TRACDCOMP( g_trac_volt, ENTER_MRK "HBToHwsvVoltageMsg::HBToHwsvVoltageMsg()" );
+    TRACDCOMP( g_trac_volt, EXIT_MRK "HBToHwsvVoltageMsg::HBToHwsvVoltageMsg()" );
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::~HBVddrMsg()
+// HBToHwsvVoltageMsg::~HBToHwsvVoltageMsg()
 ///////////////////////////////////////////////////////////////////////////////
-HBVddrMsg::~HBVddrMsg()
+HBToHwsvVoltageMsg::~HBToHwsvVoltageMsg()
 {
-    TRACDCOMP( g_trac_volt, ENTER_MRK "HBVddrMsg::~HBVddrMsg()" );
-    TRACDCOMP( g_trac_volt, EXIT_MRK "HBVddrMsg::~HBVddrMsg()" );
+    TRACDCOMP( g_trac_volt, ENTER_MRK "HBToHwsvVoltageMsg::~HBToHwsvVoltageMsg()" );
+    TRACDCOMP( g_trac_volt, EXIT_MRK "HBToHwsvVoltageMsg::~HBToHwsvVoltageMsg()" );
 };
 
 
@@ -75,8 +72,8 @@ HBVddrMsg::~HBVddrMsg()
 ///////////////////////////////////////////////////////////////////////////////
 
 bool compareVids(
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t i_lhs,
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t i_rhs)
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_lhs,
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_rhs)
 {
     bool lhsLogicallyBeforeRhs = (i_lhs.domain < i_rhs.domain);
 
@@ -90,12 +87,33 @@ bool compareVids(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// compareSequenceOrder
+///////////////////////////////////////////////////////////////////////////////
+bool compareSequenceOrder(
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_lhs,
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_rhs)
+{
+    // Sequencing order is VDN->VDD->VCS
+    // true means lhs should be ordered before rhs
+    //
+    // if both values are the same, preserve order: true
+    // if lhs is VDN, we know it goes first, order stays the same: true
+    // if rhs is VCS, we know it goes last, order stays the same: true
+    // else, lhs needs to be swapped with rhs
+    return ( (i_lhs.domainId == i_rhs.domainId) ||
+             (i_lhs.domainId == HBToHwsvVoltageMsg::VOLTAGE_DOMAIN_NEST_VDN) ||
+             (i_rhs.domainId == HBToHwsvVoltageMsg::VOLTAGE_DOMAIN_NEST_VCS) );
+
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
 // areVidsEqual
 ///////////////////////////////////////////////////////////////////////////////
 
 bool areVidsEqual(
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t i_lhs,
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t i_rhs)
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_lhs,
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_rhs)
 {
     return(   (   i_lhs.domain
                == i_rhs.domain)
@@ -103,16 +121,57 @@ bool areVidsEqual(
                == static_cast<uint16_t>(i_rhs.domainId)) );
 }
 
+
+
 ///////////////////////////////////////////////////////////////////////////////
 // isUnusedVoltageDomain
 ///////////////////////////////////////////////////////////////////////////////
 
 bool isUnusedVoltageDomain(
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t i_vid)
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t i_vid)
 {
     return (!i_vid.voltageMillivolts);
 }
 
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// removeExtraRequests
+///////////////////////////////////////////////////////////////////////////////
+void removeExtraRequests( HBToHwsvVoltageMsg::RequestContainer & io_requests,
+                          HBToHwsvVoltageMsg::VOLT_MSG_TYPE i_requestType,
+                          size_t i_targetListSize )
+{
+    if( i_targetListSize > 1 )
+    {
+        // Take out the duplicate records in io_requests by first
+        // sorting and then removing the duplicates
+        std::sort(io_requests.begin(), io_requests.end(), compareVids);
+        std::vector<HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t>::iterator
+            pInvalidEntries = std:: unique(
+                    io_requests.begin(),
+                    io_requests.end(),
+                    areVidsEqual);
+        io_requests.erase(pInvalidEntries, io_requests.end());
+    }
+
+
+    if( ( (i_requestType == HBToHwsvVoltageMsg::HB_VOLT_ENABLE) ||
+              (i_requestType == HBToHwsvVoltageMsg::HB_VOLT_POST_DRAM_INIT_ENABLE) )
+           && (i_targetListSize > 1 ) )
+    {
+            // Inhibit sending any request to turn on a domain with no voltage.
+            // When disabling we don't need to do this because the voltage is
+            // ignored.
+            io_requests.erase(
+                std::remove_if(io_requests.begin(), io_requests.end(),
+                    isUnusedVoltageDomain),io_requests.end());
+    }
+
+}
+
+
 //******************************************************************************
 // addMemoryVoltageDomains (templated)
 //******************************************************************************
@@ -122,13 +181,13 @@ template<
     const ATTRIBUTE_ID VOLTAGE_ATTR_STATIC,
     const ATTRIBUTE_ID VOLTAGE_ATTR_DYNAMIC,
     const ATTRIBUTE_ID VOLTAGE_DOMAIN_ID_ATTR >
-void HBVddrMsg::addMemoryVoltageDomains(
+void HBToHwsvVoltageMsg::addMemoryVoltageDomains(
     const TARGETING::Target* const     i_pMcbist,
-          HBVddrMsg::RequestContainer& io_domains) const
+          HBToHwsvVoltageMsg::RequestContainer& io_domains) const
 {
     assert(
-        (i_pMcbist != NULL),
-        "HBVddrMsg::addMemoryVoltageDomains: Code bug!  Caller passed NULL "
+        (i_pMcbist != nullptr),
+        "HBToHwsvVoltageMsg::addMemoryVoltageDomains: Code bug!  Caller passed NULL "
         "MCBIST target handle.");
 
     assert(
@@ -136,7 +195,7 @@ void HBVddrMsg::addMemoryVoltageDomains(
               == TARGETING::CLASS_UNIT)
           && (   i_pMcbist->getAttr<TARGETING::ATTR_TYPE>()
               == TARGETING::TYPE_MCBIST)),
-        "HBVddrMsg::addMemoryVoltageDomains: Code bug!  Caller passed non-"
+        "HBToHwsvVoltageMsg::addMemoryVoltageDomains: Code bug!  Caller passed non-"
         "MCBIST target handle of class = 0x%08X and type of 0x%08X.",
         i_pMcbist->getAttr<TARGETING::ATTR_CLASS>(),
         i_pMcbist->getAttr<TARGETING::ATTR_TYPE>());
@@ -146,7 +205,7 @@ void HBVddrMsg::addMemoryVoltageDomains(
 
     assert(
         (pSysTarget != nullptr),
-        "HBVddrMsg::addMemoryVoltageDomains: Code bug!  System target was "
+        "HBToHwsvVoltageMsg::addMemoryVoltageDomains: Code bug!  System target was "
         "NULL.");
 
     typename AttributeTraits< MSS_DOMAIN_PROGRAM >::Type
@@ -154,29 +213,29 @@ void HBVddrMsg::addMemoryVoltageDomains(
 
 
     // Initialized by constructor to invalid defaults
-    HBVddrMsg::hwsvPowrMemVoltDomainRequest_t entry;
+    HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t entry;
 
     switch(VOLTAGE_DOMAIN_ID_ATTR)
     {
         case TARGETING::ATTR_VDDR_ID:
-            entry.domain = MEM_VOLTAGE_DOMAIN_VDDR;
+            entry.domain = VOLTAGE_DOMAIN_MEM_VDDR;
             break;
         case TARGETING::ATTR_VCS_ID:
-            entry.domain = MEM_VOLTAGE_DOMAIN_VCS;
+            entry.domain = VOLTAGE_DOMAIN_MEM_VCS;
             break;
         case TARGETING::ATTR_VPP_ID:
-            entry.domain = MEM_VOLTAGE_DOMAIN_VPP;
+            entry.domain = VOLTAGE_DOMAIN_MEM_VPP;
             break;
         case TARGETING::ATTR_AVDD_ID:
-            entry.domain = MEM_VOLTAGE_DOMAIN_AVDD;
+            entry.domain = VOLTAGE_DOMAIN_MEM_AVDD;
             break;
         case TARGETING::ATTR_VDD_ID:
-            entry.domain = MEM_VOLTAGE_DOMAIN_VDD;
+            entry.domain = VOLTAGE_DOMAIN_MEM_VDD;
             break;
         default:
             assert(
                 0,
-                "HBVddrMsg::addMemoryVoltageDomains: Code Bug!  Unsupported "
+                "HBToHwsvVoltageMsg::addMemoryVoltageDomains: Code Bug!  Unsupported "
                 "voltage domain of 0x%08X.",
                 VOLTAGE_DOMAIN_ID_ATTR);
             break;
@@ -211,14 +270,14 @@ void HBVddrMsg::addMemoryVoltageDomains(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::createVddrData
+// HBToHwsvVoltageMsg::createVddrData
 ///////////////////////////////////////////////////////////////////////////////
 
-void HBVddrMsg::createVddrData(
-          VDDR_MSG_TYPE     i_requestType,
+void HBToHwsvVoltageMsg::createVddrData(
+          VOLT_MSG_TYPE     i_requestType,
           RequestContainer& io_request) const
 {
-    TRACFCOMP( g_trac_volt, ENTER_MRK "HBVddrMsg::createVddrData" );
+    TRACFCOMP( g_trac_volt, ENTER_MRK "HBToHwsvVoltageMsg::createVddrData" );
 
     // Go through all the mcbist targets and gather their domains, domain
     // specific IDs, and domain specific voltages
@@ -233,7 +292,7 @@ void HBVddrMsg::createVddrData(
 
         for (const auto & pMcbist: l_mcbistTargetList)
         {
-            if(i_requestType == HB_VDDR_ENABLE)
+            if(i_requestType == HB_VOLT_ENABLE)
             {
                 (void)addMemoryVoltageDomains<
                     TARGETING::ATTR_MSS_VDD_PROGRAM,
@@ -277,115 +336,79 @@ void HBVddrMsg::createVddrData(
                     io_request);
         }
 
-        if (l_mcbistTargetList.size() > 1)
-        {
-            // Take out the duplicate records in io_request by first
-            // sorting and then removing the duplicates
-            std::sort(io_request.begin(), io_request.end(), compareVids);
-            std::vector<hwsvPowrMemVoltDomainRequest_t>::iterator
-                pInvalidEntries = std::unique(
-                    io_request.begin(),
-                    io_request.end(),
-                    areVidsEqual);
-            io_request.erase(pInvalidEntries,io_request.end());
-        }
-
-        if( ( (i_requestType == HB_VDDR_ENABLE) ||
-              (i_requestType == HB_VDDR_POST_DRAM_INIT_ENABLE) )
-           && (!l_mcbistTargetList.empty())      )
-        {
-            // Inhibit sending any request to turn on a domain with no voltage.
-            // When disabling we don't need to do this because the voltage is
-            // ignored.
-            io_request.erase(
-                std::remove_if(io_request.begin(), io_request.end(),
-                    isUnusedVoltageDomain),io_request.end());
-        }
+        // Remove duplicate records and requests containing invalid voltages
+        removeExtraRequests( io_request,
+                             i_requestType,
+                             l_mcbistTargetList.size());
 
     } while(0);
 
-    TRACFCOMP( g_trac_volt, EXIT_MRK "HBVddrMsg::createVddrData" );
+    TRACFCOMP( g_trac_volt, EXIT_MRK "HBToHwsvVoltageMsg::createVddrData" );
     return;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::sendMsg
+// HBToHwsvVoltageMsg::sendRequestData
 ///////////////////////////////////////////////////////////////////////////////
-errlHndl_t HBVddrMsg::sendMsg(VDDR_MSG_TYPE i_msgType) const
+errlHndl_t HBToHwsvVoltageMsg::sendRequestData( RequestContainer & i_requests,
+                                       VOLT_MSG_TYPE i_msgType ) const
 {
-    errlHndl_t l_err = NULL;
 
-    TRACFCOMP(g_trac_volt, ENTER_MRK
-              "hbVddrMsg::sendMsg msg_type =0x%08X",i_msgType);
+    errlHndl_t l_err = nullptr;
 
     do
     {
-        RequestContainer l_request;
-        if (TARGETING::is_vpo())
-        {
-            TRACFCOMP(g_trac_volt,
-                "hbVddrMsg::sendMsg skipped because of VPO environment");
-            break;
-        }
+        size_t l_numRequests = i_requests.size();
+        TRACDCOMP(g_trac_volt,
+                "sendRequestData::l_numRequests = %d",
+                l_numRequests);
+
 
-        if ( ! ( (i_msgType == HB_VDDR_ENABLE) ||
-                 (i_msgType == HB_VDDR_DISABLE) ||
-                 (i_msgType == HB_VDDR_POST_DRAM_INIT_ENABLE) ) )
+        // Skip sending message if VPO
+        if( TARGETING::is_vpo())
         {
-            TRACFCOMP(g_trac_volt, ERR_MRK "hbVddrMsg::send msg with non-"
-                      "valid msg type%08X",i_msgType);
-            /*@
-             *   @errortype
-             *   @moduleid      fapi::MOD_VDDR_SEND_MSG
-             *   @reasoncode    fapi::RC_INCORRECT_MSG_TYPE
-             *   @userdata1     i_msgType
-             *   @userdata2     0
-             *
-             *   @devdesc       HB got an incorrect type message.  HB did not
-             *                  provide the correct message type in the istep.
-             *                  Userdata1 shows the message type passed in
-             */
-            createErrLog(l_err, fapi::MOD_VDDR_SEND_MSG,
-                         fapi::RC_INCORRECT_MSG_TYPE, i_msgType);
+            TRACFCOMP( g_trac_volt,
+                    "hbToHwsvVoltageMsg::sendRequestData skipped because of"
+                   "  VPO environment!" );
             break;
         }
-        createVddrData(i_msgType, l_request);
 
-        size_t l_dataCount = l_request.size();
 
         // Only send a message if there is data to send
-        // Skip sending message if VPO
-        if ( l_dataCount )
+        if( l_numRequests )
         {
-            uint32_t l_msgSize = l_dataCount *
-                sizeof(hwsvPowrMemVoltDomainRequest_t);
+            uint32_t l_msgSize = l_numRequests *
+                    sizeof(hwsvPowrMemVoltDomainRequest_t);
 
             // Create the message to send to HWSV
-            msg_t* l_msg = msg_allocate();
+            msg_t * l_msg = msg_allocate();
             l_msg->type = i_msgType;
             l_msg->data[0] = 0;
             l_msg->data[1] = l_msgSize;
 
-            TRACFCOMP(g_trac_volt, INFO_MRK "hbVddrMsg::l_dataCount=%d, "
+            TRACDCOMP(g_trac_volt, INFO_MRK "hbToHwsvVoltageMsg::l_numRequests=%d, "
                       "l_msgSize=%d",
-                      l_dataCount, l_msgSize);
+                      l_numRequests, l_msgSize);
             void* l_data = malloc(l_msgSize);
 
             hwsvPowrMemVoltDomainRequest_t* l_ptr =
                 reinterpret_cast<hwsvPowrMemVoltDomainRequest_t*>(l_data);
 
-            for (size_t j = 0; j<l_dataCount; ++j)
+            for (size_t j = 0; j<l_numRequests; ++j)
             {
-                l_ptr->domain=l_request.at(j).domain;
-                l_ptr->domainId=l_request.at(j).domainId;
-                l_ptr->voltageMillivolts=l_request.at(j).voltageMillivolts;
+                l_ptr->domain            = i_requests.at(j).domain;
+                l_ptr->domainId          = i_requests.at(j).domainId;
+                l_ptr->voltageMillivolts = i_requests.at(j).voltageMillivolts;
 
-                TRACFCOMP(g_trac_volt, ENTER_MRK "hbVddrMsg::sendMsg "
+                TRACFCOMP(g_trac_volt, ENTER_MRK "hbToHwsvVoltageMsg::sendRequestData "
                           "Voltage domain type = 0x%08X, "
                           "Voltage domain ID = 0x%04X, "
                           "Voltage (mV) = %d, index = %d",
                           l_ptr->domain,
-                          l_ptr->domainId, l_ptr->voltageMillivolts,j);
+                          l_ptr->domainId,
+                          l_ptr->voltageMillivolts,
+                          j);
                 l_ptr++;
             }
 
@@ -396,20 +419,74 @@ errlHndl_t HBVddrMsg::sendMsg(VDDR_MSG_TYPE i_msgType) const
             if (l_err)
             {
                 TRACFCOMP(g_trac_volt,
-                          ERR_MRK "Failed sending VDDR message to FSP");
+                          ERR_MRK "Failed sending voltage message to FSP");
             }
             else
             {
-                l_err=processMsg(l_msg);
+                l_err = processMsg(l_msg);
             }
 
-            // If sendrecv returns error then it may not have freed the
-            // extra_data, else need to free the response message extra_data
-            free(l_msg->extra_data);
-            l_msg->extra_data = NULL;
+            // If there is still data in l_msg->extra_data
+            if( l_msg->extra_data )
+            {
+                free(l_msg->extra_data);
+                l_msg->extra_data = nullptr;
 
-            msg_free(l_msg);
-            l_msg = NULL;
+                msg_free(l_msg);
+                l_msg = nullptr;
+            }
+        }
+    } while( 0 );
+
+    return l_err;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// HBToHwsvVoltageMsg::sendMsg
+///////////////////////////////////////////////////////////////////////////////
+errlHndl_t HBToHwsvVoltageMsg::sendMsg(VOLT_MSG_TYPE i_msgType) const
+{
+    errlHndl_t l_err = nullptr;
+
+    TRACFCOMP(g_trac_volt, ENTER_MRK
+              "hbToHwsvVoltageMsg::sendMsg msg_type =0x%08X",i_msgType);
+
+    do
+    {
+        RequestContainer l_request;
+
+        if ( ! ( (i_msgType == HB_VOLT_ENABLE) ||
+                 (i_msgType == HB_VOLT_DISABLE) ||
+                 (i_msgType == HB_VOLT_POST_DRAM_INIT_ENABLE) ) )
+        {
+            TRACFCOMP(g_trac_volt, ERR_MRK "hbToHwsvVoltageMsg::send msg with non-"
+                      "valid msg type%08X",i_msgType);
+            /*@
+             *   @errortype
+             *   @moduleid      fapi::MOD_VDDR_SEND_MSG
+             *   @reasoncode    fapi::RC_INCORRECT_MSG_TYPE
+             *   @userdata1     i_msgType
+             *   @userdata2     0
+             *
+             *   @devdesc       HB got an incorrect type message.  HB did not
+             *                  provide the correct message type in the istep.
+             *                  Userdata1 shows the message type passed in
+             */
+            createErrLog(l_err, fapi::MOD_VDDR_SEND_MSG,
+                         fapi::RC_INCORRECT_MSG_TYPE, i_msgType);
+            break;
+        }
+        createVddrData(i_msgType, l_request);
+
+        // Send the request data
+        l_err = sendRequestData( l_request, i_msgType );
+
+        if( l_err )
+        {
+            TRACFCOMP( g_trac_volt, "hbToHwsvVoltageMsg::sendMsg"
+                    "An error occurred when sending request data" );
+            break;
         }
     } while(0);
 
@@ -439,7 +516,7 @@ void calloutMcbistChildDimms( errlHndl_t & io_errl,
         for (const auto & l_dimm : l_dimmList)
         {
             TRACFCOMP( g_trac_volt, INFO_MRK
-                    "HBVddrMsg::calloutMcbistChildDimms Target HUID = 0x%08X" ,
+                    "HBToHwsvVoltageMsg::calloutMcbistChildDimms Target HUID = 0x%08X" ,
                     TARGETING::get_huid(l_dimm) );
 
             io_errl->addHwCallout( l_dimm,
@@ -458,26 +535,26 @@ void calloutMcbistChildDimms( errlHndl_t & io_errl,
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::processVDDRmsg
+// HBToHwsvVoltageMsg::processVOLTmsg
 ///////////////////////////////////////////////////////////////////////////////
-errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
+errlHndl_t  HBToHwsvVoltageMsg::processVOLTmsg(msg_t* i_recvMsg) const
 {
-    TRACFCOMP(g_trac_volt, ENTER_MRK "HBVddrMsg::processVDDRmsg");
-    errlHndl_t l_errLog = NULL;
+    TRACFCOMP(g_trac_volt, ENTER_MRK "HBToHwsvVoltageMsg::processVOLTmsg");
+    errlHndl_t l_errLog = nullptr;
 
     //check to see if an error occurred from the powr Enable/Disable functions
     //and is inside the message
     uint32_t l_msgSize = i_recvMsg->data[1];
     uint16_t l_elementCount = l_msgSize/sizeof(hwsvPowrMemVoltDomainReply_t);
-    const uint8_t* l_extraData = NULL;
+    const uint8_t* l_extraData = nullptr;
     l_extraData=static_cast<uint8_t*>(i_recvMsg->extra_data);
 
     do{
-        if (l_extraData==NULL)
+        if (l_extraData==nullptr)
         {
             //an error occurred in obtaining the extra data from the response msg
             TRACFCOMP( g_trac_volt, ERR_MRK
-                       "HBVddrMsg::processVDDRmsg: l_extraData = NULL");
+                       "HBToHwsvVoltageMsg::processVOLTmsg: l_extraData = NULL");
             //create an errorlog
             /*@
             *   @errortype
@@ -495,11 +572,11 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
             break;
         }
 
-        MEM_VOLTAGE_DOMAIN domain = MEM_VOLTAGE_DOMAIN_UNKNOWN;
+        VOLTAGE_DOMAIN domain = VOLTAGE_DOMAIN_UNKNOWN;
         TARGETING::ATTR_VDDR_ID_type l_domainId =0x0;
         uint32_t l_errPlid =0x0;
 
-        TRACFCOMP( g_trac_volt, INFO_MRK "HBVddrMsg::processVDDRmsg: "
+        TRACFCOMP( g_trac_volt, INFO_MRK "HBToHwsvVoltageMsg::processVOLTmsg: "
                     "l_elementCount=%d, l_msgSize =%d",
                     l_elementCount, l_msgSize);
         const hwsvPowrMemVoltDomainReply_t* l_ptr=
@@ -511,12 +588,12 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
             l_domainId = l_ptr->domainId;
             l_errPlid = l_ptr->plid;
 
-            TRACFCOMP( g_trac_volt, INFO_MRK "HBVddrMsg::processVDDRmsg: "
+            TRACFCOMP( g_trac_volt, INFO_MRK "HBToHwsvVoltageMsg::processVOLTmsg: "
                       "domain = 0x%08X, l_domainId=0x%08X, l_errPlid=0x%08X",
                       domain,l_domainId,l_errPlid);
             if (l_errPlid == 0x0)
             {
-                TRACFCOMP( g_trac_volt, INFO_MRK "HBVddrMsg::processVDDRmsg: "
+                TRACFCOMP( g_trac_volt, INFO_MRK "HBToHwsvVoltageMsg::processVOLTmsg: "
                           "no plid error found for domain = 0x%08X, "
                           "l_domainId=0x%08X", domain, l_domainId);
             }
@@ -525,7 +602,7 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
                 //error occurred so break out of the loop and indicate
                 //an error was present
                 TRACFCOMP( g_trac_volt, ERR_MRK
-                           "HBVddrMsg::processVDDRmsg: error occurred "
+                           "HBToHwsvVoltageMsg::processVOLTmsg: error occurred "
                            "on the powr function called in hwsv");
                 //create an errorlog
                 /*@
@@ -560,23 +637,23 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
                     switch(domain)
                     {
                         // Add hw callouts for child DIMMs
-                        case MEM_VOLTAGE_DOMAIN_VDDR:
+                        case VOLTAGE_DOMAIN_MEM_VDDR:
                             l_attr_domainId =
                                 pMcbist->getAttr< TARGETING::ATTR_VDDR_ID >();
                             break;
-                        case MEM_VOLTAGE_DOMAIN_VCS:
+                        case VOLTAGE_DOMAIN_MEM_VCS:
                             l_attr_domainId =
                                    pMcbist->getAttr< TARGETING::ATTR_VCS_ID>();
                             break;
-                        case MEM_VOLTAGE_DOMAIN_VPP:
+                        case VOLTAGE_DOMAIN_MEM_VPP:
                             l_attr_domainId =
                                     pMcbist->getAttr< TARGETING::ATTR_VPP_ID>();
                             break;
-                        case MEM_VOLTAGE_DOMAIN_AVDD:
+                        case VOLTAGE_DOMAIN_MEM_AVDD:
                             l_attr_domainId =
                                    pMcbist->getAttr< TARGETING::ATTR_AVDD_ID>();
                             break;
-                        case MEM_VOLTAGE_DOMAIN_VDD:
+                        case VOLTAGE_DOMAIN_MEM_VDD:
                             l_attr_domainId =
                                     pMcbist->getAttr< TARGETING::ATTR_VDD_ID>();
                             break;
@@ -592,7 +669,7 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
                     if((l_domain_found) && ( l_attr_domainId == l_domainId ))
                     {
                         TRACFCOMP( g_trac_volt, INFO_MRK
-                         "HBVddrMsg::processVDDRmsg MCBIST Target HUID = 0x%08X"
+                         "HBToHwsvVoltageMsg::processVOLTmsg MCBIST Target HUID = 0x%08X"
                          " matches failing domain 0x%08X and ID = 0x%08X",
                          TARGETING::get_huid(pMcbist), domain, l_domainId );
 
@@ -607,17 +684,17 @@ errlHndl_t  HBVddrMsg::processVDDRmsg(msg_t* i_recvMsg) const
             l_ptr++;
         }
     }while(0);
-    TRACFCOMP(g_trac_volt, EXIT_MRK "HBVddrMsg::processVDDRmsg");
+    TRACFCOMP(g_trac_volt, EXIT_MRK "HBToHwsvVoltageMsg::processVOLTmsg");
     return l_errLog;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::processMsg
+// HBToHwsvVoltageMsg::processMsg
 ///////////////////////////////////////////////////////////////////////////////
-errlHndl_t HBVddrMsg::processMsg(msg_t* i_Msg) const
+errlHndl_t HBToHwsvVoltageMsg::processMsg(msg_t* i_Msg) const
 {
-    TRACFCOMP(g_trac_volt, ENTER_MRK "HBVddrMsg::processMsg");
-    errlHndl_t l_errLog = NULL;
+    TRACFCOMP(g_trac_volt, ENTER_MRK "HBToHwsvVoltageMsg::processMsg");
+    errlHndl_t l_errLog = nullptr;
 
     do
     {
@@ -631,13 +708,13 @@ errlHndl_t HBVddrMsg::processMsg(msg_t* i_Msg) const
             //process a response to a request
             uint32_t l_msgType =i_Msg->type;
             TRACFCOMP( g_trac_volt, INFO_MRK
-                       "HBVddrMsg::processMsg l_msgType=x%08X",l_msgType );
-            if ( (l_msgType == HB_VDDR_ENABLE) ||
-                 (l_msgType == HB_VDDR_DISABLE)||
-                 (l_msgType == HB_VDDR_POST_DRAM_INIT_ENABLE) )
+                       "HBToHwsvVoltageMsg::processMsg l_msgType=x%08X",l_msgType );
+            if ( (l_msgType == HB_VOLT_ENABLE) ||
+                 (l_msgType == HB_VOLT_DISABLE)||
+                 (l_msgType == HB_VOLT_POST_DRAM_INIT_ENABLE) )
             {
-                //process a VDDR message
-                l_errLog=processVDDRmsg(i_Msg);
+                //process a voltage message
+                l_errLog=processVOLTmsg(i_Msg);
                 if (l_errLog)
                 {
                     break;
@@ -646,7 +723,7 @@ errlHndl_t HBVddrMsg::processMsg(msg_t* i_Msg) const
             else
             {
                 TRACFCOMP( g_trac_volt, ERR_MRK
-                           "HBVddrMsg::processMsg recv'd a non valid type");
+                           "HBToHwsvVoltageMsg::processMsg recv'd a non valid type");
                 //generate errorLog;
                 /*@
                  *   @errortype
@@ -667,7 +744,7 @@ errlHndl_t HBVddrMsg::processMsg(msg_t* i_Msg) const
         {
             //an error occurred so should stop the IPL
             TRACFCOMP( g_trac_volt, ERR_MRK
-                       "HBVddrMsg::RecvMsgHndlr recv'd an error message" );
+                       "HBToHwsvVoltageMsg::RecvMsgHndlr recv'd an error message" );
 
             //generate an errorlog
             /*@
@@ -690,19 +767,19 @@ errlHndl_t HBVddrMsg::processMsg(msg_t* i_Msg) const
 
     }while(0);
 
-    TRACFCOMP(g_trac_volt, EXIT_MRK "HBVddrMsg::processMsg");
+    TRACFCOMP(g_trac_volt, EXIT_MRK "HBToHwsvVoltageMsg::processMsg");
     return l_errLog;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// HBVddrMsg::createErrLog
+// HBToHwsvVoltageMsg::createErrLog
 ///////////////////////////////////////////////////////////////////////////////
-void HBVddrMsg::createErrLog(errlHndl_t& io_err,
+void HBToHwsvVoltageMsg::createErrLog(errlHndl_t& io_err,
                              fapi::hwpfModuleId i_mod,
                              fapi::hwpfReasonCode i_rc,
                              uint32_t i_userData1) const
 {
-    if (io_err == NULL)
+    if (io_err == nullptr)
     {
         io_err = new ErrlEntry(ERRL_SEV_UNRECOVERABLE,
                                 i_mod,
@@ -715,9 +792,12 @@ void HBVddrMsg::createErrLog(errlHndl_t& io_err,
 }
 
 // External interfaces
+////////////////////////////////////////////////////////////////////////////////
+// platform_enable_vddr
+////////////////////////////////////////////////////////////////////////////////
 errlHndl_t platform_enable_vddr()
 {
-    errlHndl_t l_err = NULL;
+    errlHndl_t l_err = nullptr;
 
     TARGETING::Target* pSysTarget = nullptr;
     TARGETING::targetService().getTopLevelTarget(pSysTarget);
@@ -729,9 +809,9 @@ errlHndl_t platform_enable_vddr()
     if((pSysTarget->getAttr< TARGETING::ATTR_SUPPORTS_DYNAMIC_MEM_VOLT >() == 1)
         && (INITSERVICE::spBaseServicesEnabled()))
     {
-        HBVddrMsg l_hbVddr;
+        HBToHwsvVoltageMsg l_hbVddr;
 
-        l_err = l_hbVddr.sendMsg(HBVddrMsg::HB_VDDR_ENABLE);
+        l_err = l_hbVddr.sendMsg(HBToHwsvVoltageMsg::HB_VOLT_ENABLE);
         if (l_err)
         {
             TRACFCOMP(g_trac_volt,
@@ -755,14 +835,18 @@ errlHndl_t platform_enable_vddr()
     return l_err;
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+// platform_disable_vddr
+////////////////////////////////////////////////////////////////////////////////
 errlHndl_t platform_disable_vddr()
 {
-    errlHndl_t l_err = NULL;
+    errlHndl_t l_err = nullptr;
     if(INITSERVICE::spBaseServicesEnabled())
     {
-        HBVddrMsg l_hbVddr;
+        HBToHwsvVoltageMsg l_hbToHwsv;
 
-        l_err = l_hbVddr.sendMsg(HBVddrMsg::HB_VDDR_DISABLE);
+        l_err = l_hbToHwsv.sendMsg(HBToHwsvVoltageMsg::HB_VOLT_DISABLE);
         if (l_err)
         {
             TRACFCOMP(g_trac_volt,
@@ -785,14 +869,18 @@ errlHndl_t platform_disable_vddr()
     return l_err;
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+// platform_adjust_vddr_post_dram_init
+////////////////////////////////////////////////////////////////////////////////
 errlHndl_t platform_adjust_vddr_post_dram_init()
 {
-    errlHndl_t l_err = NULL;
+    errlHndl_t l_err = nullptr;
     if(INITSERVICE::spBaseServicesEnabled())
     {
-        HBVddrMsg l_hbVddr;
+        HBToHwsvVoltageMsg l_hbVddr;
 
-        l_err = l_hbVddr.sendMsg(HBVddrMsg::HB_VDDR_POST_DRAM_INIT_ENABLE);
+        l_err = l_hbVddr.sendMsg(HBToHwsvVoltageMsg::HB_VOLT_POST_DRAM_INIT_ENABLE);
         if (l_err)
         {
             TRACFCOMP(g_trac_volt,
@@ -815,3 +903,107 @@ errlHndl_t platform_adjust_vddr_post_dram_init()
     return l_err;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// platform_set_nest_voltages
+////////////////////////////////////////////////////////////////////////////////
+errlHndl_t platform_set_nest_voltages()
+{
+    errlHndl_t l_err = nullptr;
+
+    TARGETING::TargetHandleList l_procList;
+
+    HBToHwsvVoltageMsg::RequestContainer l_requests;
+
+    HBToHwsvVoltageMsg::VOLT_MSG_TYPE l_requestType =
+                              HBToHwsvVoltageMsg::HB_VOLT_POST_DRAM_INIT_ENABLE;
+
+    // Get the system's processors
+    TARGETING::getAllChips( l_procList,
+                            TARGETING::TYPE_PROC,
+                            true ); // true: return functional procs
+
+    for( const auto & l_procTarget : l_procList )
+    {
+
+        // Only send Voltage Rail data if not connected by AVSBus
+        //    -Denoted with a value of 0xFF in the Busnum for the rail
+
+        // VDN Rail
+        if( l_procTarget->getAttr<TARGETING::ATTR_VDN_AVSBUS_BUSNUM>() == 0xff )
+        {
+            HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t l_vdnRequest;
+
+            // Populate VDN request
+            l_vdnRequest.domain = HBToHwsvVoltageMsg::VOLTAGE_DOMAIN_NEST_VDN;
+            l_vdnRequest.domainId = l_procTarget->getAttr<TARGETING::ATTR_NEST_VDN_ID>();
+            l_vdnRequest.voltageMillivolts =
+                            l_procTarget->getAttr<TARGETING::ATTR_VDN_BOOT_VOLTAGE>();
+            l_requests.push_back( l_vdnRequest );
+        }
+
+        // VDD Rail
+        if( l_procTarget->getAttr<TARGETING::ATTR_VDD_AVSBUS_BUSNUM>() == 0xff)
+        {
+            // Create VRD Requests
+            HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t l_vddRequest;
+
+            // Populate VDD request
+            l_vddRequest.domain = HBToHwsvVoltageMsg::VOLTAGE_DOMAIN_NEST_VDD;
+            l_vddRequest.domainId = l_procTarget->getAttr<TARGETING::ATTR_NEST_VDD_ID>();
+            l_vddRequest.voltageMillivolts =
+                         l_procTarget->getAttr<TARGETING::ATTR_VDD_BOOT_VOLTAGE>();
+            l_requests.push_back( l_vddRequest );
+        }
+
+
+        // VCS Rail
+        if( l_procTarget->getAttr<TARGETING::ATTR_VCS_AVSBUS_BUSNUM>() == 0xff )
+        {
+            HBToHwsvVoltageMsg::hwsvPowrMemVoltDomainRequest_t l_vcsRequest;
+            // Populate VCS request
+            l_vcsRequest.domain = HBToHwsvVoltageMsg::VOLTAGE_DOMAIN_NEST_VCS;
+            l_vcsRequest.domainId = l_procTarget->getAttr<TARGETING::ATTR_NEST_VCS_ID>();
+            l_vcsRequest.voltageMillivolts =
+                            l_procTarget->getAttr<TARGETING::ATTR_VCS_BOOT_VOLTAGE>();
+            l_requests.push_back( l_vcsRequest );
+        }
+
+    } // Processor Loop
+
+
+    //Remove duplicate records and requests with invalid voltages
+    removeExtraRequests( l_requests,
+                         l_requestType,
+                         l_procList.size() );
+    TRACDCOMP(g_trac_volt,
+            "platform_set_nest_voltages - Sending %d requests", l_requests.size());
+
+
+    // Sort the list based on sequencing order
+    std::sort(l_requests.begin(), l_requests.end(), compareSequenceOrder );
+
+    size_t l_requestsSize = l_requests.size();
+    for( size_t i = 0; i < l_requestsSize ; i++ )
+    {
+        TRACDCOMP(g_trac_volt,
+                  "Rail data: domain = 0x%x, domainId = %d, mV = %d",
+                  l_requests.at(i).domain,
+                  l_requests.at(i).domainId,
+                  l_requests.at(i).voltageMillivolts );
+    }
+    //Send the actual data to HWSV
+    HBToHwsvVoltageMsg l_hbToHwsv;
+    l_err = l_hbToHwsv.sendRequestData(l_requests,
+                                     HBToHwsvVoltageMsg::HB_VOLT_POST_DRAM_INIT_ENABLE );
+
+    if( l_err )
+    {
+        TRACFCOMP(g_trac_volt,
+                ERR_MRK"hbToHwsvVoltageMsg.C::platform_set_nest_voltages - "
+                "Failed to send the Request Data to HWSV!" );
+    }
+
+
+    return l_err;
+}
+
diff --git a/src/usr/isteps/istep13/hbVddrMsg.H b/src/usr/isteps/hbToHwsvVoltageMsg.H
index 1f491b7b5..5f66a2a9d 100644
--- a/src/usr/isteps/istep13/hbVddrMsg.H
+++ b/src/usr/isteps/hbToHwsvVoltageMsg.H
@@ -1,7 +1,7 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: src/usr/isteps/istep13/hbVddrMsg.H $                          */
+/* $Source: src/usr/isteps/hbToHwsvVoltageMsg.H $                         */
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
@@ -23,8 +23,8 @@
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
 
-#ifndef __HB_VDDR_MSG_H
-#define __HB_VDDR_MSG_H
+#ifndef __HB_VOLT_MSG_H
+#define __HB_VOLT_MSG_H
 
 /*****************************************************************************/
 // I n c l u d e s
@@ -52,15 +52,15 @@
 /*****************************************************************************/
 // Forward class declarations
 /*****************************************************************************/
-class HBVddrMsg;
+class HBToHwsvVoltageMsg;
 
 /**
- *  @brief  HBVddrMsg
+ *  @brief  HBToHwsvVoltageMsg
  *  This class provides interfaces to send and process messages to and from
  *  hwsv with respect to powr.  It also indicates when to stop the IPL via
  *  errorlogs
  */
-class HBVddrMsg
+class HBToHwsvVoltageMsg
 {
 
 public:
@@ -68,21 +68,26 @@ public:
     /**
      *  @brief Enum specifying a memory voltage domain type
      */
-    enum MEM_VOLTAGE_DOMAIN
+    enum VOLTAGE_DOMAIN
     {
         // For unknown / uninitialized values
-        MEM_VOLTAGE_DOMAIN_UNKNOWN = 0x00,
+        VOLTAGE_DOMAIN_UNKNOWN = 0x00,
 
         // Valid values
-        MEM_VOLTAGE_DOMAIN_VDD  = 0x01,
-        MEM_VOLTAGE_DOMAIN_AVDD = 0x02,
-        MEM_VOLTAGE_DOMAIN_VCS  = 0x03,
-        MEM_VOLTAGE_DOMAIN_VPP  = 0x04,
-        MEM_VOLTAGE_DOMAIN_VDDR = 0x05,  // aka VMEM
+        VOLTAGE_DOMAIN_MEM_VDD       = 0x01,
+        VOLTAGE_DOMAIN_MEM_AVDD      = 0x02,
+        VOLTAGE_DOMAIN_MEM_VCS       = 0x03,
+        VOLTAGE_DOMAIN_MEM_VPP       = 0x04,
+        VOLTAGE_DOMAIN_MEM_VDDR      = 0x05,  // aka VMEM
+        VOLTAGE_DOMAIN_NEST_VDD      = 0x06,
+        VOLTAGE_DOMAIN_NEST_VDN      = 0x07,
+        VOLTAGE_DOMAIN_NEST_VCS      = 0x08,
+        VOLTAGE_DOMAIN_NEST_VIO      = 0x09,
+        VOLTAGE_DOMAIN_NEST_VDDR     = 0x0A,
 
         // Good range markers - Need to be adjusted if the above change
-        MEM_VOLTAGE_DOMAIN_MIN_VALUE = MEM_VOLTAGE_DOMAIN_VDD,
-        MEM_VOLTAGE_DOMAIN_MAX_VALUE = MEM_VOLTAGE_DOMAIN_VDDR,
+        VOLTAGE_DOMAIN_MIN_VALUE = VOLTAGE_DOMAIN_MEM_VDD,
+        VOLTAGE_DOMAIN_MAX_VALUE = VOLTAGE_DOMAIN_NEST_VDDR,
     };
 
     /**
@@ -93,12 +98,12 @@ public:
      */
     struct hwsvPowrMemVoltDomainRequest_t
     {
-        MEM_VOLTAGE_DOMAIN            domain;
-        TARGETING::ATTR_VDDR_ID_type  domainId;
-        TARGETING::ATTR_MSS_VOLT_VDDR_MILLIVOLTS_type voltageMillivolts;
+        VOLTAGE_DOMAIN      domain;
+        uint16_t            domainId;
+        uint32_t            voltageMillivolts;
 
         hwsvPowrMemVoltDomainRequest_t()
-            : domain(MEM_VOLTAGE_DOMAIN_UNKNOWN),
+            : domain(VOLTAGE_DOMAIN_UNKNOWN),
               domainId(0x0000),
               voltageMillivolts(0x00000000)
         {
@@ -115,12 +120,12 @@ public:
      */
     struct hwsvPowrMemVoltDomainReply_t
     {
-        MEM_VOLTAGE_DOMAIN           domain;
-        TARGETING::ATTR_VDDR_ID_type domainId;
-        uint32_t                     plid;
+        VOLTAGE_DOMAIN        domain;
+        uint16_t              domainId;
+        uint32_t              plid;
 
         hwsvPowrMemVoltDomainReply_t()
-            : domain(MEM_VOLTAGE_DOMAIN_UNKNOWN),
+            : domain(VOLTAGE_DOMAIN_UNKNOWN),
               domainId(0x0000),
               plid(0x00000000)
         {
@@ -129,16 +134,16 @@ public:
     } __attribute__ ((packed));
 
     /**
-     * @enum VDDR_MSG_TYPE
+     * @enum VOLT_MSG_TYPE
      *
      * @brief  Message enum to determine how the msg should be processed
      *
      */
-    enum VDDR_MSG_TYPE
+    enum VOLT_MSG_TYPE
     {
-        HB_VDDR_ENABLE = 0x40000041,
-        HB_VDDR_DISABLE = 0x40000042,
-        HB_VDDR_POST_DRAM_INIT_ENABLE = 0x40000043,
+        HB_VOLT_ENABLE = 0x40000041,
+        HB_VOLT_DISABLE = 0x40000042,
+        HB_VOLT_POST_DRAM_INIT_ENABLE = 0x40000043,
     };
 
     /**
@@ -150,7 +155,7 @@ public:
     /**
      * @brief Default constructor
      */
-    HBVddrMsg();
+    HBToHwsvVoltageMsg();
 
     /**
      * @brief   Destructor
@@ -160,7 +165,7 @@ public:
      * @return  None
      *
      */
-    ~HBVddrMsg();
+    ~HBToHwsvVoltageMsg();
 
     /**
      *  @brief Accumulates memory voltage domain type/ID/voltage records and
@@ -183,7 +188,7 @@ public:
      *  @return N/A
      */
     void createVddrData(
-              VDDR_MSG_TYPE     i_requestType,
+              VOLT_MSG_TYPE     i_requestType,
               RequestContainer& io_request) const;
 
     /**
@@ -195,14 +200,30 @@ public:
       *          FSP_VDDR_MSGQ as the message queue..
       *
       *  @param[in] i_msgType
-      *             HBVddrMsg::VDDR_MSG_TYPE passed in to define the
+      *             HBToHwsvVoltageMsg::VDDR_MSG_TYPE passed in to define the
       *             message policy.
       *
       *  @return     errlHndl_t
       *              return errl ==  NULL  -> success
       *              return errl !=  NULL  -> failure
      */
-    errlHndl_t sendMsg(VDDR_MSG_TYPE i_msgType) const;
+    errlHndl_t sendMsg(VOLT_MSG_TYPE i_msgType) const;
+
+
+    /**
+     * @brief Appropriately formats the request data and sends it to the FSP
+     *
+     * @param[in]     i_requests - A vector of requests
+     * @param[in]     i_msgType - the type of message we are sending
+     *
+     * @ return errlHndl_t
+     *          return errl == NULL  -> success
+     *          return errl != NULL  -> failure
+     */
+    errlHndl_t sendRequestData( RequestContainer & i_requests,
+                                VOLT_MSG_TYPE i_msgType ) const;
+
+
 
 private:
 
@@ -254,7 +275,7 @@ private:
         const TARGETING::ATTRIBUTE_ID VOLTAGE_DOMAIN_ID_ATTR >
     void addMemoryVoltageDomains(
         const TARGETING::Target* const     i_pMcbist,
-              HBVddrMsg::RequestContainer& io_domains) const;
+              HBToHwsvVoltageMsg::RequestContainer& io_domains) const;
 
 protected:
 
@@ -283,7 +304,7 @@ protected:
      *              return errl ==  NULL  -> success
      *              return errl !=  NULL  -> failure
      */
-    errlHndl_t processVDDRmsg(msg_t* i_recvMsg)const;
+    errlHndl_t processVOLTmsg(msg_t* i_recvMsg)const;
 
      /**
      * @brief function to create error logs for errors that occured in FSP side
@@ -303,7 +324,14 @@ protected:
                       fapi::hwpfReasonCode i_rc,
                       uint32_t i_userData1=0x0) const;
 
+
 };
 
+//External Interfaces
+/**
+ * @brief Send processor voltage rail data to HWSV
+ * @return NULL | error handle on error
+ */
+errlHndl_t platform_set_nest_voltages();
 
 #endif
diff --git a/src/usr/isteps/istep08/call_host_set_voltages.C b/src/usr/isteps/istep08/call_host_set_voltages.C
index bbe6f10cf..a791fac39 100644
--- a/src/usr/isteps/istep08/call_host_set_voltages.C
+++ b/src/usr/isteps/istep08/call_host_set_voltages.C
@@ -29,6 +29,7 @@
 #include <trace/interface.H>
 #include <errl/errlentry.H>
 #include <initservice/isteps_trace.H>
+#include <initservice/initserviceif.H>
 #include <isteps/hwpisteperror.H>
 // targeting support
 #include <targeting/common/commontargeting.H>
@@ -37,10 +38,11 @@
 #include <fapi2/target.H>
 #include <fapi2/plat_hwp_invoker.H>
 
-
 #include <p9_setup_evid.H>
 
 
+#include <hbToHwsvVoltageMsg.H>
+
 using namespace TARGETING;
 using namespace ERRORLOG;
 using namespace ISTEP_ERROR;
@@ -59,10 +61,10 @@ void* call_host_set_voltages(void *io_pArgs)
     errlHndl_t l_err = NULL;
     TargetHandleList l_procList;
     IStepError l_stepError;
-
+    bool l_noError = true;
     do
     {
-        // Get the systems procs
+        // Get the system's procs
         getAllChips( l_procList,
                      TYPE_PROC,
                      true ); // true: return functional procs
@@ -91,9 +93,33 @@ void* call_host_set_voltages(void *io_pArgs)
                 l_stepError.addErrorDetails( l_err );
 
                 errlCommit( l_err, HWPF_COMP_ID );
+                l_noError = false;
             }
-        } // Processor loop
+        } // Processor Loop
+
+        if( l_noError )
+        {
+#if 0 // TODO RTC: 160517 - Uncomment the call to send processor voltage data to HWSV
+            //If FSP is present, send voltage information to HWSV
+            if( INITSERVICE::spBaseServicesEnabled() )
+            {
+                l_err = platform_set_nest_voltages();
+
+                if( l_err )
+                {
+                    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "Error in call_host_set_voltages::platform_set_nest_voltages()")
+
+                    // Create IStep error log and cross reference occurred error
+                    l_stepError.addErrorDetails( l_err );
 
+                    //Commit Error
+                    errlCommit( l_err, ISTEP_COMP_ID );
+
+                }
+            }
+#endif
+        }
     }while( 0 );
 
 
diff --git a/src/usr/isteps/istep08/makefile b/src/usr/isteps/istep08/makefile
index af1eb8796..f95e2b97f 100644
--- a/src/usr/isteps/istep08/makefile
+++ b/src/usr/isteps/istep08/makefile
@@ -68,7 +68,6 @@ VPATH += ${PROCEDURES_PATH}/hwp/sbe/
 VPATH += ${PROCEDURES_PATH}/hwp/pm/
 VPATH += ${PROCEDURES_PATH}/hwp/lib
 
-
 include ${ROOTPATH}/procedure.rules.mk
 # host_slave_sbe_config
 include ${PROCEDURES_PATH}/hwp/perv/p9_setup_sbe_config.mk
diff --git a/src/usr/isteps/istep13/makefile b/src/usr/isteps/istep13/makefile
index cad151156..1ba3369a0 100644
--- a/src/usr/isteps/istep13/makefile
+++ b/src/usr/isteps/istep13/makefile
@@ -46,7 +46,6 @@ EXTRAINCDIR += ${PROCEDURES_PATH}/hwp/nest
 EXTRAINCDIR += ${PROCEDURES_PATH}/hwp/initfiles
 
 
-
 # from src/usr/isteps/istep13
 OBJS += call_host_disable_memvolt.o
 OBJS += call_mem_pll_reset.o
@@ -61,7 +60,6 @@ OBJS += call_mss_draminit_training.o
 OBJS += call_mss_draminit_trainadv.o
 OBJS += call_mss_draminit_mc.o
 
-OBJS += $(if $(CONFIG_OPENPOWER_VDDR),openpower_vddr.o,hbVddrMsg.o)
 
 #HWP build tool
 include ${ROOTPATH}/procedure.rules.mk
diff --git a/src/usr/isteps/makefile b/src/usr/isteps/makefile
index ac376aab2..fcef26385 100644
--- a/src/usr/isteps/makefile
+++ b/src/usr/isteps/makefile
@@ -48,6 +48,7 @@ OBJS += hwpistepud.o
 OBJS += istepHelperFuncs.o
 OBJS += pbusLinkSvc.o
 
+OBJS += $(if $(CONFIG_OPENPOWER_VOLTMSG),openpower_vddr.o,hbToHwsvVoltageMsg.o)
 
 EXTRAINCDIR += ${ROOTPATH}/src/usr/initservice/istepdispatcher
 EXTRAINCDIR += ${ROOTPATH}/src/import/hwpf/fapi2/include/
diff --git a/src/usr/isteps/istep13/openpower_vddr.C b/src/usr/isteps/openpower_vddr.C
index 5d8b4c8fc..e05c1fd1d 100644
--- a/src/usr/isteps/istep13/openpower_vddr.C
+++ b/src/usr/isteps/openpower_vddr.C
@@ -1,7 +1,7 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: src/usr/isteps/istep13/openpower_vddr.C $                     */
+/* $Source: src/usr/isteps/openpower_vddr.C $                             */
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
diff --git a/src/usr/isteps/istep13/platform_vddr.H b/src/usr/isteps/platform_vddr.H
index 81520bb9a..a9b44a96e 100644
--- a/src/usr/isteps/istep13/platform_vddr.H
+++ b/src/usr/isteps/platform_vddr.H
@@ -1,7 +1,7 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: src/usr/isteps/istep13/platform_vddr.H $                      */
+/* $Source: src/usr/isteps/platform_vddr.H $                              */
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */