ADU HWP updates for CI support, performance

  adjustments to support long running CI operations
    ignore autoinc mode for CI ttype
    include poll for data done prior to final status check

  ignore ADU operational/data hang reporting

  correctly report num_granules when running without autoinc

  performance enhancements:
    minimize SCOM operations for single shot transfers (15->9)
    reduce polling delays

  add simple test program to validate transfer sizes, measure perf

Change-Id: I341ae28a767cc4195e8b52a237bcb509152e5ba1
Original-Change-Id: Ic1f3890ff40f448fb1143d639d878896e90237fd
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/36086
Dev-Ready: Brent Wieman <bwieman@us.ibm.com>
Tested-by: PPE CI <ppe-ci+hostboot@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Hostboot CI <hostboot-ci+hostboot@us.ibm.com>
Reviewed-by: Thi N. Tran <thi@us.ibm.com>
Reviewed-by: Joseph J. McGill <jmcgill@us.ibm.com>
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/49799
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-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>

2 files changed, 42 insertions, 13 deletions

diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_adu_access.C b/src/import/chips/p9/procedures/hwp/nest/p9_adu_access.C
index 4270aa000..65c650670 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_adu_access.C
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_adu_access.C
@@ -67,6 +67,15 @@ extern "C" {
         // Process input flag
         p9_ADU_oper_flag l_myAduFlag;
         l_myAduFlag.getFlag(i_flags);
+        FAPI_DBG("l_myAduFlag = %lu", l_myAduFlag);
+
+        //If autoinc is set and this is not a DMA operation unset autoinc before passing the flags through
+        if (l_myAduFlag.getOperationType() != p9_ADU_oper_flag::DMA_PARTIAL)
+        {
+            l_myAduFlag.setAutoIncrement(false);
+        }
+
+        FAPI_DBG("l_myAduFlag = %lu", l_myAduFlag);
 
         if( i_lastGranule && l_myAduFlag.getAutoIncrement() )
         {
@@ -100,9 +109,12 @@ extern "C" {
                 l_busyHandling = EXPECTED_BUSY_BIT_CLEAR;
             }
 
-            FAPI_TRY(p9_adu_coherent_status_check(i_target, l_busyHandling, false,
-                                                  l_busyBitStatus),
-                     "Error from p9_adu_coherent_status_check");
+            if (l_myAduFlag.getOperationType() != p9_ADU_oper_flag::CACHE_INHIBIT)
+            {
+                FAPI_TRY(p9_adu_coherent_status_check(i_target, l_busyHandling, false,
+                                                      l_busyBitStatus),
+                         "Error from p9_adu_coherent_status_check");
+            }
 
             //If it's the last read/write
             if (i_lastGranule)
diff --git a/src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.C b/src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.C
index e272b381d..8736dc254 100644
--- a/src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.C
+++ b/src/import/chips/p9/procedures/hwp/nest/p9_adu_setup.C
@@ -65,32 +65,49 @@ extern "C"
         bool adu_is_dirty = false;
         bool adu_leave_dirty = i_flags & FLAG_LEAVE_DIRTY;
 
+        // Process input flag
+        p9_ADU_oper_flag l_myAduFlag;
+        l_myAduFlag.getFlag(i_flags);
+
+        //If autoinc is set and this is not a DMA operation unset autoinc before passing the flags through
+        if (l_myAduFlag.getOperationType() != p9_ADU_oper_flag::DMA_PARTIAL)
+        {
+            l_myAduFlag.setAutoIncrement(false);
+        }
+
+        uint32_t l_flags = l_myAduFlag.setFlag();
+
         //check arguments
-        FAPI_TRY(p9_adu_coherent_utils_check_args(i_target, i_address, i_flags),
+        FAPI_TRY(p9_adu_coherent_utils_check_args(i_target, i_address, l_flags),
                  "Error from p9_adu_coherent_utils_check_args");
 
         //ensure fabric is running
         FAPI_TRY(p9_adu_coherent_utils_check_fbc_state(i_target),
                  "Error from p9_adu_coherent_utils_check_fbc_status");
 
-        //reset ADU state machines and status register
-        FAPI_TRY(p9_adu_coherent_utils_reset_adu(i_target), "p9_adu_setup: Error from p9_adu_coherent_utils_reset_adu");
-
         //acquire ADU lock to guarantee exclusive use of the ADU resources
-        lock_pick = i_flags & FLAG_LOCK_PICK;
-        num_attempts = i_flags & FLAG_LOCK_TRIES;
+        //ADU state machine will be reset/cleared by this routine
+        lock_pick = l_flags & FLAG_LOCK_PICK;
+        num_attempts = l_flags & FLAG_LOCK_TRIES;
         FAPI_TRY(p9_adu_coherent_manage_lock(i_target, lock_pick, true, num_attempts),
                  "Error from p9_adu_coherent_manage_lock");
 
-        //figure out how many granules can be requested before setup needs to be run again
-        FAPI_TRY(p9_adu_coherent_utils_get_num_granules(i_address, o_numGranules),
-                 "Error from p9_adu_coherent_utils_get_num_granules");
+        if (l_myAduFlag.getAutoIncrement() == true)
+        {
+            //figure out how many granules can be requested before setup needs to be run again
+            FAPI_TRY(p9_adu_coherent_utils_get_num_granules(i_address, o_numGranules),
+                     "Error from p9_adu_coherent_utils_get_num_granules");
+        }
+        else
+        {
+            o_numGranules = 1;
+        }
 
         //Set dirty since we need to attempt to cleanup/release the lock so the ADU is not in a locked state if operation fails from this point
         adu_is_dirty = true;
 
         //setup the ADU registers for the read/write
-        FAPI_TRY(p9_adu_coherent_setup_adu(i_target, i_address, i_rnw, i_flags),
+        FAPI_TRY(p9_adu_coherent_setup_adu(i_target, i_address, i_rnw, l_flags),
                  "Error from p9_adu_coherent_setup_registers");
 
     fapi_try_exit: