p9_build_smp -- use ADU chipops to switch fabric configuration part #2

p9_build_smp HWP code is modified to invoke new p9_putmemproc FAPI
HWP via FAPI_CALL_SUBROUTINE
  HB platform must invoke SBE chipop under the covers for security
  Cronus may directly invoke p9_putmemproc body in an insecure system

Change-Id: I34b90ce906e8caaf3ce86e728228f634ce136d33
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/49692
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: PPE CI <ppe-ci+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: Matt K. Light <mklight@us.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/49695
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

5 files changed, 145 insertions, 321 deletions

diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_adu_constants.H b/src/import/chips/p9/procedures/hwp/nest/p9_adu_constants.H
index 8929516da..261535072 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_adu_constants.H
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_adu_constants.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -55,6 +55,9 @@ extern "C"
         // 0b010: PB disable op
         // 0b011: PMISC op
         // 0b100: PB enable op
+        // 0b101: pre-switch CD setup
+        // 0b110: pre-switch AB setup
+        // 0b111: post-switch AB/CD cleanup
         FLAG_ADU_TTYPE = 0xE0000000ull,                        // Bits 0:2
 
         // Utilize ADU HW auto-increment function
diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.C b/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.C
index d88b39268..78c52f970 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.C
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -38,10 +38,11 @@
 // Includes
 //------------------------------------------------------------------------------
 #include <p9_build_smp_adu.H>
-#include <p9_adu_coherent_utils.H>
+#include <p9_putmemproc.H>
 #include <p9_perv_scom_addresses.H>
 #include <p9_misc_scom_addresses.H>
 #include <p9_misc_scom_addresses_fld.H>
+#include <fapi2_subroutine_executor.H>
 
 //------------------------------------------------------------------------------
 // Constants
@@ -87,169 +88,139 @@ const uint32_t P9_BUILD_SMP_FFDC_REGS[P9_BUILD_SMP_FFDC_NUM_REGS] =
 /// @brief Check ADU status matches expected state/value
 ///        NOTE: intended to be run while holding ADU lock
 ///
-/// @param[in] i_target                P9 target
-/// @param[in] i_smp                   Structure encapsulating SMP topology
-/// @return fapi2:ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+/// @param[in] i_smp   Structure encapsulating SMP topology
+/// @param[inout] o_rc FAPI error code to be appended with FFDC
+/// @return void
 ///
-fapi2::ReturnCode p9_build_smp_adu_check_status(
-    const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
-    p9_build_smp_system& i_smp)
+void p9_build_smp_append_ffdc(
+    p9_build_smp_system& i_smp,
+    fapi2::ReturnCode& o_rc)
 {
     FAPI_DBG("Start");
-    fapi2::ReturnCode l_rc;
-    uint32_t l_num_polls = 0;
-    bool l_busy_bit_status = false;
 
-    // SMP SWITCH expect BUSY BIT to be clear
-    adu_status_busy_handler l_busy_handling = EXIT_ON_BUSY;
-
-    // Wait for operation to be completed (busy bit cleared)
-    while (l_num_polls < P9_BUILD_SMP_MAX_STATUS_POLLS)
+    // collect FFDC
+    fapi2::variable_buffer l_chip_data_valid(8 * P9_BUILD_SMP_MAX_SIZE);
+    fapi2::variable_buffer l_group_ids(8 * P9_BUILD_SMP_MAX_SIZE);
+    fapi2::variable_buffer l_chip_ids(8 * P9_BUILD_SMP_MAX_SIZE);
+    fapi2::variable_buffer l_ffdc_addrs(64 * P9_BUILD_SMP_FFDC_NUM_REGS);
+    fapi2::variable_buffer l_ffdc_reg_data(64 * P9_BUILD_SMP_MAX_SIZE * P9_BUILD_SMP_FFDC_NUM_REGS);
+    uint8_t l_idx = 0;
+
+    // init buffers
+    l_chip_data_valid.flush<0>();
+    l_group_ids.flush<1>();
+    l_chip_ids.flush<1>();
+    l_ffdc_reg_data.flush<1>();
+
+    for (uint8_t jj = 0; jj < P9_BUILD_SMP_FFDC_NUM_REGS; jj++)
     {
-        l_rc = p9_adu_coherent_status_check(i_target,
-                                            l_busy_handling,
-                                            true,
-                                            l_busy_bit_status);
-
-        if (l_rc)
-        {
-            FAPI_ERR("p9_adu_coherent_status_check() returns error");
-            break;
-        }
-
-        if (l_busy_bit_status == true)
-        {
-            l_num_polls++;
-
-            // last try, set handler to expect busy bit clear, if not then
-            // p9_adu_coherent_status_check() will log an error so that
-            // we don't have to deal with the error separately here.
-            if (l_num_polls == (P9_BUILD_SMP_MAX_STATUS_POLLS - 1))
-            {
-                l_busy_handling = EXPECTED_BUSY_BIT_CLEAR;
-            }
-        }
-        else
-        {
-            // Operation done, break out
-            break;
-        }
+        l_ffdc_addrs.set<uint64_t>(jj, P9_BUILD_SMP_FFDC_REGS[jj]);
     }
 
-    FAPI_DBG("Num of polls %u", l_num_polls);
-
-    if (l_rc)
+    // extract FFDC data
+    for (auto n_iter = i_smp.groups.begin();
+         n_iter != i_smp.groups.end();
+         n_iter++)
     {
-        fapi2::current_err = l_rc;
-        // collect FFDC
-        fapi2::variable_buffer l_chip_data_valid(8 * P9_BUILD_SMP_MAX_SIZE);
-        fapi2::variable_buffer l_group_ids(8 * P9_BUILD_SMP_MAX_SIZE);
-        fapi2::variable_buffer l_chip_ids(8 * P9_BUILD_SMP_MAX_SIZE);
-        fapi2::variable_buffer l_ffdc_addrs(64 * P9_BUILD_SMP_FFDC_NUM_REGS);
-        fapi2::variable_buffer l_ffdc_reg_data(64 * P9_BUILD_SMP_MAX_SIZE * P9_BUILD_SMP_FFDC_NUM_REGS);
-        uint8_t l_idx = 0;
-
-        // init buffers
-        l_chip_data_valid.flush<0>();
-        l_group_ids.flush<1>();
-        l_chip_ids.flush<1>();
-        l_ffdc_reg_data.flush<1>();
-
-        for (uint8_t jj = 0; jj < P9_BUILD_SMP_FFDC_NUM_REGS; jj++)
-        {
-            l_ffdc_addrs.set<uint64_t>(jj, P9_BUILD_SMP_FFDC_REGS[jj]);
-        }
-
-        // extract FFDC data
-        for (auto n_iter = i_smp.groups.begin();
-             n_iter != i_smp.groups.end();
-             n_iter++)
+        for (auto p_iter = n_iter->second.chips.begin();
+             p_iter != n_iter->second.chips.end();
+             p_iter++)
         {
-            for (auto p_iter = n_iter->second.chips.begin();
-                 p_iter != n_iter->second.chips.end();
-                 p_iter++)
+            // mark valid
+            (void) l_chip_data_valid.set<uint8_t>(l_idx, 0x1);
+            // log group/chip ID
+            (void) l_group_ids.set<uint8_t>(l_idx, n_iter->first);
+            (void) l_chip_ids.set<uint8_t>(l_idx, p_iter->first);
+
+            // collect SCOM data
+            for (uint8_t jj = 0; jj < P9_BUILD_SMP_FFDC_NUM_REGS; jj++)
             {
-                // mark valid
-                (void) l_chip_data_valid.set<uint8_t>(l_idx, 0x1);
-                // log group/chip ID
-                (void) l_group_ids.set<uint8_t>(l_idx, n_iter->first);
-                (void) l_chip_ids.set<uint8_t>(l_idx, p_iter->first);
-
-                // collect SCOM data
-                for (uint8_t jj = 0; jj < P9_BUILD_SMP_FFDC_NUM_REGS; jj++)
+                fapi2::buffer<uint64_t> l_scom_data;
+                fapi2::ReturnCode l_scom_rc;
+                // discard bad SCOM return codes, mark data as all ones
+                // and keep collecting
+                l_scom_rc = fapi2::getScom(*(p_iter->second.target),
+                                           P9_BUILD_SMP_FFDC_REGS[jj],
+                                           l_scom_data);
+
+                if (l_scom_rc)
                 {
-                    fapi2::buffer<uint64_t> l_scom_data;
-                    fapi2::ReturnCode l_scom_rc;
-                    // discard bad SCOM return codes, mark data as all ones
-                    // and keep collecting
-                    l_scom_rc = fapi2::getScom(*(p_iter->second.target),
-                                               P9_BUILD_SMP_FFDC_REGS[jj],
-                                               l_scom_data);
-
-                    if (l_scom_rc)
-                    {
-                        l_scom_data.flush<1>();
-                    }
-
-                    (void) l_ffdc_reg_data.set<uint64_t>((P9_BUILD_SMP_FFDC_NUM_REGS * l_idx) + jj,
-                                                         l_scom_data());
+                    l_scom_data.flush<1>();
                 }
 
-                l_idx++;
+                (void) l_ffdc_reg_data.set<uint64_t>((P9_BUILD_SMP_FFDC_NUM_REGS * l_idx) + jj,
+                                                     l_scom_data());
             }
-        }
 
-        FAPI_ASSERT(false,
-                    fapi2::P9_BUILD_SMP_ADU_STATUS_MISMATCH_ERR()
-                    .set_TARGET(i_target)
-                    .set_ADU_NUM_POLLS(l_num_polls)
-                    .set_CHIP_DATA_VALID(&l_chip_data_valid)
-                    .set_GROUP_IDS(l_group_ids)
-                    .set_CHIP_IDS(l_chip_ids)
-                    .set_FFDC_ADDRS(l_ffdc_addrs)
-                    .set_FFDC_REG_DATA(l_ffdc_reg_data),
-                    "Status mismatch detected on ADU operation");
+            l_idx++;
+        }
     }
 
-fapi_try_exit:
-    FAPI_DBG("End");
-    return fapi2::current_err;
+    fapi2::ffdc_t CHIP_DATA_VALID;
+    fapi2::ffdc_t GROUP_IDS;
+    fapi2::ffdc_t CHIP_IDS;
+    fapi2::ffdc_t FFDC_ADDRS;
+    fapi2::ffdc_t FFDC_REG_DATA;
+
+    CHIP_DATA_VALID.ptr() = static_cast<void*>(&l_chip_data_valid);
+    CHIP_DATA_VALID.size() = sizeof(l_chip_data_valid);
+    GROUP_IDS.ptr() = static_cast<void*>(&l_group_ids);
+    GROUP_IDS.size() = sizeof(l_group_ids);
+    CHIP_IDS.ptr() = static_cast<void*>(&l_chip_ids);
+    CHIP_IDS.size() = sizeof(l_chip_ids);
+    FFDC_ADDRS.ptr() = static_cast<void*>(&l_ffdc_addrs);
+    FFDC_ADDRS.size() = sizeof(l_ffdc_addrs);
+    FFDC_REG_DATA.ptr() = static_cast<void*>(&l_ffdc_reg_data);
+    FFDC_REG_DATA.size() = sizeof(l_ffdc_reg_data);
+
+    FAPI_ADD_INFO_TO_HWP_ERROR(o_rc, RC_P9_BUILD_SMP_ADU_STATUS_MISMATCH_ERR);
 }
 
 
 ///
 /// @brief Set action which will occur on fabric pmisc switch command
-///        NOTE: intended to be run while holding ADU lock
 ///
-/// @param[in] i_target        Processor chip target
-/// @param[in] i_switch_ab     Perform switch AB operation?
-/// @param[in] i_switch_cd     Perform switch CD operation?
+/// @param[in] i_target    Processor chip target
+/// @param[in] i_action    Enumerated type representing fabric operation
 ///
 /// @return fapi2:ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
 ///
 fapi2::ReturnCode p9_build_smp_adu_set_switch_action(
     const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,
-    const bool i_switch_ab,
-    const bool i_switch_cd)
+    const p9_build_smp_adu_action i_action)
 {
     FAPI_DBG("Start");
-    fapi2::buffer<uint64_t> pmisc_data;
-    fapi2::buffer<uint64_t> pmisc_mask;
 
-    // Build ADU pMisc Mode register content
-    FAPI_DBG("writing ADU pMisc Mode register: switch_ab=%s, switch_cd=%s",
-             i_switch_ab ? "true" : "false", i_switch_cd ? "true" : "false");
+    fapi2::ReturnCode l_rc;
+    uint64_t l_addr = 0x0ULL;
+    uint32_t l_bytes = 1;
+    uint32_t l_flags = SBE_MEM_ACCESS_FLAGS_TARGET_PROC;
+    uint8_t l_data_unused[1];
 
-    // Switch AB bit
-    pmisc_data.writeBit<PU_SND_MODE_REG_ENABLE_PB_SWITCH_AB>(i_switch_ab);
-    pmisc_mask.setBit<PU_SND_MODE_REG_ENABLE_PB_SWITCH_AB>();
+    if (i_action == SWITCH_AB)
+    {
+        l_flags |= SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_AB_MODE;
+    }
+    else if (i_action == SWITCH_CD)
+    {
+        l_flags |= SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_CD_MODE;
+    }
+    else
+    {
+        l_flags |= SBE_MEM_ACCESS_FLAGS_POST_SWITCH_MODE;
+    }
 
-    // Switch CD bit
-    pmisc_data.writeBit<PU_SND_MODE_REG_ENABLE_PB_SWITCH_CD>(i_switch_cd);
-    pmisc_mask.setBit<PU_SND_MODE_REG_ENABLE_PB_SWITCH_CD>();
+    // issue operation
+    FAPI_CALL_SUBROUTINE(fapi2::current_err,
+                         p9_putmemproc,
+                         i_target,
+                         l_addr,
+                         l_bytes,
+                         l_data_unused,
+                         l_flags);
 
-    FAPI_TRY(fapi2::putScomUnderMask(i_target, PU_SND_MODE_REG, pmisc_data, pmisc_mask),
-             "Error from putScomUnderMask (PU_SND_MODE_REG)");
+    FAPI_TRY(fapi2::current_err,
+             "Error from p9_putmemproc");
 
 fapi_try_exit:
     FAPI_DBG("End");
@@ -264,27 +235,22 @@ fapi2::ReturnCode p9_build_smp_sequence_adu(p9_build_smp_system& i_smp,
 {
     FAPI_DBG("Start");
     fapi2::ReturnCode l_rc;
-    bool l_lock_pick = (i_op == SMP_ACTIVATE_PHASE1) ?
-                       P9_BUILD_SMP_PHASE1_ADU_PICK_LOCK :
-                       P9_BUILD_SMP_PHASE2_ADU_PICK_LOCK;
-    uint8_t l_num_attempts = (i_op == SMP_ACTIVATE_PHASE1) ?
-                             P9_BUILD_SMP_PHASE1_ADU_LOCK_ATTEMPTS :
-                             P9_BUILD_SMP_PHASE2_ADU_LOCK_ATTEMPTS;
-    bool l_adu_is_dirty = false;
 
     // validate input action, set ADU operation parameters
-    p9_ADU_oper_flag l_adu_oper_flag;
+    uint32_t l_flags = SBE_MEM_ACCESS_FLAGS_TARGET_PROC;
+    uint32_t l_bytes = 1;
+    uint64_t l_addr = 0x0ULL;
+    uint8_t l_data_unused[1];
 
     switch (i_action)
     {
         case SWITCH_AB:
         case SWITCH_CD:
-            l_adu_oper_flag.setOperationType(p9_ADU_oper_flag::PMISC_OPER);
-            l_adu_oper_flag.setTransactionSize(p9_ADU_oper_flag::TSIZE_1);
+            l_flags |= SBE_MEM_ACCESS_FLAGS_SWITCH_MODE;
             break;
 
         case QUIESCE:
-            l_adu_oper_flag.setOperationType(p9_ADU_oper_flag::PB_DIS_OPER);
+            l_flags |= SBE_MEM_ACCESS_FLAGS_PB_DIS_MODE;
             break;
 
         default:
@@ -295,8 +261,8 @@ fapi2::ReturnCode p9_build_smp_sequence_adu(p9_build_smp_system& i_smp,
                         "Invalid ADU action specified");
     }
 
-    // loop through all chips, lock & reset ADU
-    FAPI_DBG("Acquiring lock for all ADU units in drawer");
+    // loop through all chips, set switch operation
+    FAPI_DBG("Setting switch controls");
 
     for (auto g_iter = i_smp.groups.begin();
          g_iter != i_smp.groups.end();
@@ -306,65 +272,21 @@ fapi2::ReturnCode p9_build_smp_sequence_adu(p9_build_smp_system& i_smp,
              p_iter != g_iter->second.chips.end();
              ++p_iter)
         {
-            // acquire ADU lock
-            l_rc = p9_adu_coherent_manage_lock(
-                       *(p_iter->second.target),
-                       l_lock_pick,
-                       true,           // Acquire lock
-                       l_num_attempts);
-
-            if (l_rc)
-            {
-                FAPI_ERR("Error from p9_adu_coherent_manage_lock (acquire all)");
-
-                if (l_adu_is_dirty)
-                {
-                    goto adu_reset_unlock;
-                }
-                else
-                {
-                    fapi2::current_err = l_rc;
-                    goto fapi_try_exit;
-                }
-            }
-
-            // NOTE: lock is now held, if an operation fails from this point
-            //       to the end of the procedure:
-            //         o attempt to cleanup/release lock (so that procedure does
-            //         not leave the ADU in a locked state)
-            //         o return rc of original fail
-            l_adu_is_dirty = true;
-
-            // Reset ADU
-            l_rc = p9_adu_coherent_utils_reset_adu(*(p_iter->second.target));
-
-            if (l_rc)
-            {
-                FAPI_ERR("Error from p9_adu_coherent_utils_reset_adu (acquire all)");
-                goto adu_reset_unlock;
-            }
-
             // Condition for hotplug switch operation
             // all chips which were not quiesced prior to switch AB will
             // need to observe the switch
             if (i_action != QUIESCE)
             {
-                l_rc = p9_build_smp_adu_set_switch_action(
-                           *(p_iter->second.target),
-                           (i_action == SWITCH_AB),
-                           (i_action == SWITCH_CD));
-
-                if (l_rc)
-                {
-                    FAPI_ERR("Error from p9_build_smp_adu_set_switch_action (acquire all)");
-                    goto adu_reset_unlock;
-                }
+                FAPI_TRY(p9_build_smp_adu_set_switch_action(
+                             *(p_iter->second.target),
+                             i_action),
+                         "Error from p9_build_smp_adu_set_switch_action (set)");
             }
         }
     }
 
     // perform action on specified chips
-    FAPI_DBG("All ADU locks now held, performing action = %d", i_action);
+    FAPI_DBG("Performing action = %d", i_action);
 
     for (auto g_iter = i_smp.groups.begin();
          g_iter != i_smp.groups.end();
@@ -386,67 +308,22 @@ fapi2::ReturnCode p9_build_smp_sequence_adu(p9_build_smp_system& i_smp,
                 FAPI_INF("Issuing ADU op for %s", l_target_str);
 
                 // issue operation
-                l_rc = p9_adu_coherent_setup_adu(*(p_iter->second.target),
-                                                 0,
-                                                 false,      // write
-                                                 l_adu_oper_flag.setFlag());
-
-                if (l_rc)
-                {
-                    FAPI_ERR("Error from p9_adu_coherent_setup_adu (op)");
-                    goto adu_reset_unlock;
-                }
-
-                // Check status
-                l_rc = p9_build_smp_adu_check_status(
-                           *(p_iter->second.target),
-                           i_smp);
-
-                if (l_rc)
-                {
-                    FAPI_ERR("Error from p9_build_smp_adu_check_status (op)");
-                    goto adu_reset_unlock;
-                }
-
-                // workaround for HW397129 to re-enable fastpath for DD1
-                uint8_t l_hw397129_workaround;
-                FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_HW397129, *(p_iter->second.target), l_hw397129_workaround),
-                         "Error from FAPI_ATTR_GET (ATTR_CHIP_EC_FEATURE_HW397129)");
-
-                if ((i_action == SWITCH_AB) && l_hw397129_workaround)
-                {
-                    p9_ADU_oper_flag l_adu_oper_flag_reinit;
-                    l_adu_oper_flag_reinit.setOperationType(p9_ADU_oper_flag::PB_INIT_OPER);
-                    l_adu_oper_flag_reinit.setTransactionSize(p9_ADU_oper_flag::TSIZE_1);
-
-                    FAPI_INF("Issuing re-init for HW397129");
-                    l_rc = p9_adu_coherent_setup_adu(*(p_iter->second.target),
-                                                     0,
-                                                     false,      // write
-                                                     l_adu_oper_flag_reinit.setFlag());
-
-                    if (l_rc)
-                    {
-                        FAPI_ERR("Error from p9_adu_coherent_setup_adu (op, reinit)");
-                        goto adu_reset_unlock;
-                    }
-
-                    // Check status
-                    l_rc = p9_build_smp_adu_check_status(*(p_iter->second.target),
-                                                         i_smp);
-
-                    if (l_rc)
-                    {
-                        FAPI_ERR("Error from p9_build_smp_adu_check_status (op, reinit)");
-                        goto adu_reset_unlock;
-                    }
-                }
+                FAPI_CALL_SUBROUTINE(fapi2::current_err,
+                                     p9_putmemproc,
+                                     (*(p_iter->second.target)),
+                                     l_addr,
+                                     l_bytes,
+                                     l_data_unused,
+                                     l_flags);
+
+                FAPI_TRY(fapi2::current_err,
+                         "Error from p9_putmemproc");
             }
         }
     }
 
-    // loop through all chips, reset switch controls and unlock ADUs
-    FAPI_DBG("Operation complete, releasing lock for all ADU units in drawer");
+    // loop through all chips, reset switch controls
+    FAPI_DBG("Operation complete, resetting switch controls");
 
     for (auto g_iter = i_smp.groups.begin();
          g_iter != i_smp.groups.end();
@@ -459,65 +336,10 @@ fapi2::ReturnCode p9_build_smp_sequence_adu(p9_build_smp_system& i_smp,
             // reset switch controls
             if (i_action != QUIESCE)
             {
-                l_rc = p9_build_smp_adu_set_switch_action(
-                           *(p_iter->second.target),
-                           false,
-                           false);
-
-                if (l_rc)
-                {
-                    FAPI_ERR("Error from p9_build_smp_adu_set_switch_action (release all)");
-                    goto adu_reset_unlock;
-                }
-            }
-
-            // release ADU lock
-            l_lock_pick = false;
-            l_rc = p9_adu_coherent_manage_lock(*(p_iter->second.target),
-                                               l_lock_pick,
-                                               false, // Release lock
-                                               l_num_attempts);
-
-            if (l_rc)
-            {
-                FAPI_ERR("Error from p9_adu_coherent_manage_lock (release all)");
-                goto adu_reset_unlock;
-            }
-        }
-    }
-
-    FAPI_DBG("All ADU locks released");
-    // no error for entire operation
-    l_adu_is_dirty = false;
-
-adu_reset_unlock:
-
-    // if error has occurred and any ADU is dirty,
-    // attempt to reset all ADUs and free locks (propogate rc of original fail)
-    if (l_rc && l_adu_is_dirty)
-    {
-        // save original error for return
-        fapi2::current_err = l_rc;
-
-        FAPI_INF("Attempting to reset/free lock on all ADUs");
-
-        // loop through all chips, unlock ADUs
-        for (auto g_iter = i_smp.groups.begin();
-             g_iter != i_smp.groups.end();
-             ++g_iter)
-        {
-            for (auto p_iter = g_iter->second.chips.begin();
-                 p_iter != g_iter->second.chips.end();
-                 ++p_iter)
-            {
-                // ignore return codes
-                l_rc = p9_adu_coherent_utils_reset_adu(
-                           *(p_iter->second.target));
-                l_rc = p9_adu_coherent_manage_lock(
-                           *(p_iter->second.target),
-                           false, // No lock pick
-                           false, // Lock release
-                           1);    // Attempt 1 time
+                FAPI_TRY(p9_build_smp_adu_set_switch_action(
+                             *(p_iter->second.target),
+                             p9_build_smp_adu_action::RESET_SWITCH),
+                         "Error from p9_build_smp_adu_set_switch_action (clear)");
             }
         }
     }
diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.H b/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.H
index 3086e75ee..7d1929e5f 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.H
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_build_smp_adu.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -51,7 +51,8 @@ enum p9_build_smp_adu_action
 {
     SWITCH_AB = 1,
     SWITCH_CD = 2,
-    QUIESCE   = 4
+    QUIESCE   = 4,
+    RESET_SWITCH = 8
 };
 
 
diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_putmemproc.H b/src/import/chips/p9/procedures/hwp/nest/p9_putmemproc.H
index 8e461c46b..83247fccb 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_putmemproc.H
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_putmemproc.H
@@ -56,12 +56,12 @@ enum sbeMemoryAccessFlags
     SBE_MEM_ACCESS_FLAGS_CACHE_INHIBITED_MODE = 0x00000080,
     SBE_MEM_ACCESS_FLAGS_HOST_PASS_THROUGH    = 0x00000100,
     SBE_MEM_ACCESS_FLAGS_CACHE_INJECT_MODE    = 0x00000200,
-    SBE_MEM_ACCESS_FLAGS_PB_DIS_MODE          = 0x00001000,
-    SBE_MEM_ACCESS_FLAGS_SWITCH_MODE          = 0x00002000,
-    SBE_MEM_ACCESS_FLAGS_PB_INIT_MODE         = 0x00004000,
-    SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_CD_MODE   = 0x00008000,
-    SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_AB_MODE   = 0x00010000,
-    SBE_MEM_ACCESS_FLAGS_POST_SWITCH_MODE     = 0x00020000,
+    SBE_MEM_ACCESS_FLAGS_PB_DIS_MODE          = 0x00000400,
+    SBE_MEM_ACCESS_FLAGS_SWITCH_MODE          = 0x00000800,
+    SBE_MEM_ACCESS_FLAGS_PB_INIT_MODE         = 0x00001000,
+    SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_CD_MODE   = 0x00002000,
+    SBE_MEM_ACCESS_FLAGS_PRE_SWITCH_AB_MODE   = 0x00004000,
+    SBE_MEM_ACCESS_FLAGS_POST_SWITCH_MODE     = 0x00008000,
 };
 
 //------------------------------------------------------------------------------
diff --git a/src/import/chips/p9/procedures/xml/error_info/p9_build_smp_errors.xml b/src/import/chips/p9/procedures/xml/error_info/p9_build_smp_errors.xml
index c06bd5c3e..0a63accfc 100644
--- a/src/import/chips/p9/procedures/xml/error_info/p9_build_smp_errors.xml
+++ b/src/import/chips/p9/procedures/xml/error_info/p9_build_smp_errors.xml
@@ -5,7 +5,7 @@
 <!--                                                                        -->
 <!-- OpenPOWER HostBoot Project                                             -->
 <!--                                                                        -->
-<!-- Contributors Listed Below - COPYRIGHT 2015,2017                        -->
+<!-- Contributors Listed Below - COPYRIGHT 2015,2018                        -->
 <!-- [+] International Business Machines Corp.                              -->
 <!--                                                                        -->
 <!--                                                                        -->
@@ -169,8 +169,6 @@
     <description>
       Status mismatch detected on ADU operation execution for SMP configuration.
     </description>
-    <ffdc>TARGET</ffdc>
-    <ffdc>ADU_NUM_POLLS</ffdc>
     <ffdc>CHIP_DATA_VALID</ffdc>
     <ffdc>GROUP_IDS</ffdc>
     <ffdc>CHIP_IDS</ffdc>