SBE Psu Host pass through

Change-Id: I2d357ed234da22b9c38d8d7c5b0d8a04689f9328
RTC: 159753
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/39087
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: AMIT J. TENDOLKAR <amit.tendolkar@in.ibm.com>

8 files changed, 212 insertions, 7 deletions

diff --git a/src/sbefw/sbeHostUtils.H b/src/sbefw/sbeHostUtils.H
index 092c884b..33fc9db8 100644
--- a/src/sbefw/sbeHostUtils.H
+++ b/src/sbefw/sbeHostUtils.H
@@ -93,6 +93,11 @@ typedef enum
     // This would be used to trigger hostboot in istep 16
     SBE_SBE2PSU_DOORBELL_SET_BIT2      = 0x2000000000000000ull,
 
+    // Bit 4 OR flag for SBE->PSU Doorbell Register,
+    // When this is set by SBE, it would trigger an interrupt to host
+    // firmware to inform that Host Pass through command received.
+    SBE_SBE2PSU_DOORBELL_SET_BIT4      = 0x0800000000000000ull,
+
     // Bit 14 OR flag for SBE->PSU Doorbell Register;
     // When this is set by SBE, it would trigger an interrupt to host
     // firmware to inform that timer has expired.
diff --git a/src/sbefw/sbeSpMsg.H b/src/sbefw/sbeSpMsg.H
index 65308ff1..c24c5e1c 100644
--- a/src/sbefw/sbeSpMsg.H
+++ b/src/sbefw/sbeSpMsg.H
@@ -428,6 +428,17 @@ typedef struct
         return l_len;
     }
 
+    /**
+      * @brief Determines if it is Host Pass-through Command
+      *
+      * @return Returns True if Host Pass-through mode is set
+      *                 False if Host Pass-through mode is not set
+      */
+    uint32_t isPbaHostPassThroughModeSet() const
+    {
+        return ((flags & SBE_MEM_ACCESS_FLAGS_HOST_PASS_THROUGH) ? true : false);
+    }
+
 }sbeMemAccessReqMsgHdr_t;
 
 /**
diff --git a/src/sbefw/sbe_sp_intf.H b/src/sbefw/sbe_sp_intf.H
index fdc49770..45dfafdc 100644
--- a/src/sbefw/sbe_sp_intf.H
+++ b/src/sbefw/sbe_sp_intf.H
@@ -293,6 +293,7 @@ enum sbeMemoryAccessFlags
     SBE_MEM_ACCESS_FLAGS_FAST_MODE_ON       = 0x0020,
     SBE_MEM_ACCESS_FLAGS_LCO_ENABLED        = 0x0040, //required only in PBA-PUT
     SBE_MEM_ACCESS_FLAGS_CACHE_INHIBIT      = 0x0080, //required in I/O oper ADU
+    SBE_MEM_ACCESS_FLAGS_HOST_PASS_THROUGH  = 0x0100, // Host pass through mode (PBA)
     SBE_MEM_ACCESS_FLAGS_INJECT_ON          = 0x0200, // Inject mode ( PBA put )
 };
 
diff --git a/src/sbefw/sbecmdmemaccess.C b/src/sbefw/sbecmdmemaccess.C
index aa582e45..93126d49 100644
--- a/src/sbefw/sbecmdmemaccess.C
+++ b/src/sbefw/sbecmdmemaccess.C
@@ -35,6 +35,8 @@
 #include "sbetrace.H"
 #include "sbeFifoMsgUtils.H"
 #include "sbeutil.H"
+#include "sbeHostUtils.H"
+#include "sbeglobals.H"
 
 #include "fapi2.H"
 
@@ -181,7 +183,33 @@ uint32_t processPbaRequest(const sbeMemAccessReqMsgHdr_t &i_hdr,
 
     // Default for PBA
     uint32_t l_granuleSize = PBA_GRAN_SIZE_BYTES;
-    uint64_t l_addr = i_hdr.getAddr();
+    uint64_t l_addr = 0;
+
+    // If not Host Pass through command, simply set the addr from the command
+    if(!i_hdr.isPbaHostPassThroughModeSet())
+    {
+        l_addr = i_hdr.getAddr();
+    }
+    // If it is Host Pass through command, set the address using the Host pass
+    // through address already set in the global and using the addr here in the
+    // command as index to that address
+    else
+    {
+        l_addr = SBE_GLOBAL->hostPassThroughCmdAddr.addr + i_hdr.getAddr();
+        // Check if the size pass in the command is less than the size mentioned
+        // in the Host Pass Through globals
+        if((i_hdr.getAddr() + i_hdr.len) > SBE_GLOBAL->hostPassThroughCmdAddr.size)
+        {
+            // Break out, Invalid Size
+            SBE_ERROR("User size[0x%08X] exceeds the Host Pass Through Mode "
+                "size[0x%08X] Start Index[0x%08X %08X]", 
+                i_hdr.len, SBE_GLOBAL->hostPassThroughCmdAddr.size,
+                SBE::higher32BWord(i_hdr.getAddr()),
+                SBE::lower32BWord(i_hdr.getAddr()));
+            l_respHdr.setStatus( SBE_PRI_INVALID_DATA,
+                                 SBE_SEC_GENERIC_FAILURE_IN_EXECUTION );
+        }
+    }
 
     // Default EX Target Init..Not changing it for the time being
     Target<TARGET_TYPE_EX> l_ex(
@@ -237,6 +265,12 @@ uint32_t processPbaRequest(const sbeMemAccessReqMsgHdr_t &i_hdr,
 
     while (l_granulesCompleted < l_lenCacheAligned)
     {
+        // Breaking out here if invalid size
+        if(l_respHdr.primaryStatus != SBE_PRI_OPERATION_SUCCESSFUL)
+        {
+            break;
+        }
+
         // If this is putmem request, read input data from the upstream FIFO
         if (!i_isFlagRead)
         {
@@ -298,6 +332,11 @@ uint32_t processPbaRequest(const sbeMemAccessReqMsgHdr_t &i_hdr,
         CHECK_SBE_RC_AND_BREAK_IF_NOT_SUCCESS(l_rc);
 
         l_rc = sbeDsSendRespHdr( l_respHdr, &l_ffdc);
+        // Indicate the host in put pass through mode via Interrupt
+        if(!l_rc && i_hdr.isPbaHostPassThroughModeSet() && !i_isFlagRead)
+        {
+            l_rc = sbeSetSbe2PsuDbBitX(SBE_SBE2PSU_DOORBELL_SET_BIT4);
+        }
     } while(false);
 
     SBE_EXIT(SBE_FUNC);
diff --git a/src/test/testcases/testAduMem_124B.py b/src/test/testcases/testAduMem_124B.py
index 82336896..9d6cd146 100644
--- a/src/test/testcases/testAduMem_124B.py
+++ b/src/test/testcases/testAduMem_124B.py
@@ -82,7 +82,7 @@ def main( ):
 
 # Test case 4: Invalid length - 3
     # GetMemAdu test
-    testMemProcUtil.getmem_failure(0x08000000, 3, 0xA5)
+    testMemProcUtil.getmem_failure(0x08000000, 3, 0xA5, 0x0002000A)
     print ("Success - invalid length test")
 
 #-------------------------------------------------
diff --git a/src/test/testcases/testMemUtil.py b/src/test/testcases/testMemUtil.py
index d44c56ea..c6b5ab96 100644
--- a/src/test/testcases/testMemUtil.py
+++ b/src/test/testcases/testMemUtil.py
@@ -119,7 +119,7 @@ def getmem(addr, len, flags):
     testUtil.readEot( )
     return data[:lenExp]
 
-def getmem_failure(addr, len, flags):
+def getmem_failure(addr, len, flags, responseWord):
     req = (getsingleword(6)
          + [0, 0, 0xA4, 0x01]
          + getsingleword(flags)
@@ -127,9 +127,9 @@ def getmem_failure(addr, len, flags):
          + getsingleword(len))
     testUtil.writeUsFifo(req)
     testUtil.writeEot( )
-    expResp =  [0x0, 0x0, 0x0, 0x0,
-                0xc0,0xde,0xa4,0x01,
-                0x0,0x2,0x0,0xa,
-                0x0,0x0,0x0,0x03];
+    expResp =  ([0x0, 0x0, 0x0, 0x0]
+    + [0xc0,0xde,0xa4,0x01]
+    + getsingleword(responseWord)
+    + [0x0,0x0,0x0,0x03])
     testUtil.readDsFifo(expResp)
     testUtil.readEot( )
diff --git a/src/test/testcases/testPsuHostPassThrough.py b/src/test/testcases/testPsuHostPassThrough.py
new file mode 100644
index 00000000..d63bd212
--- /dev/null
+++ b/src/test/testcases/testPsuHostPassThrough.py
@@ -0,0 +1,144 @@
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/test/testcases/testPsuHostPassThrough.py $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 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
+
+import sys
+sys.path.append("targets/p9_nimbus/sbeTest" )
+import testPSUUtil
+import testRegistry as reg
+import testUtil
+import testMemUtil
+
+#-------------------------------
+# This  is a Test Expected Data
+#-------------------------------
+'''
+This data are the values or strings that needs to be validated for the test.
+'''
+'''
+#------------------------------------------------------------------------------------------------------------------------------
+# SBE side test data -
+#------------------------------------------------------------------------------------------------------------------------------
+'''
+sbe_test_data = (
+    #-----------------------------------------------------------------------------------------------------
+    #   OP      Reg                               ValueToWrite         size    Test Expected Data       Description
+    #-----------------------------------------------------------------------------------------------------
+    #                        FFDC Size, Pass CMD Size
+    ["write", reg.REG_MBOX0, "0000010000F0D704", 	 8, 	"None", 		"Writing to MBOX0 address"],
+    #                        FFDC Size, Pass CMD Size
+    ["write", reg.REG_MBOX1, "0000010000000100", 	 8, 	"None", 		"Writing to MBOX1 address"],
+    #                           FFDC Addr
+    ["write", reg.REG_MBOX2, "1234567898765432", 	 8, 	"None", 			"Writing to MBOX2 address"],
+    #                           Pass Cmd Addr
+    ["write", reg.REG_MBOX3, "0000000008000000", 	 8, 	"None", 			"Writing to MBOX3 address"],
+    ["write", reg.PSU_SBE_DOORBELL_REG_WO_OR, "8000000000000000", 	 8, 	"None", 		"Update SBE Doorbell register to interrupt SBE"],
+    )
+'''
+#---------------------
+# Host side test data - SUCCESS
+#---------------------
+'''
+host_test_data_success = (
+    #----------------------------------------------------------------------------------------------------------------
+    #   OP     Reg                                 ValueToWrite        size    Test Expected Data        Description
+    #----------------------------------------------------------------------------------------------------------------
+    ["read", reg.REG_MBOX4, 		"0", 	 	 8, 	"0000000000F0D704", "Reading Host MBOX4 data to Validate"],
+    )
+
+'''
+#-----------------------------------------------------------------------
+# Do not modify - Used to simulate interrupt on Ringing Doorbell on Host
+#-----------------------------------------------------------------------
+'''
+host_polling_data = (
+    #----------------------------------------------------------------------------------------------------------------
+    #   OP     Reg                                 ValueToWrite        size    Test Expected Data           Description
+    #----------------------------------------------------------------------------------------------------------------
+    ["read", reg.PSU_HOST_DOORBELL_REG_WO_OR, 		"0", 		8, "8000000000000000", "Reading Host Doorbell for Interrupt Bit0"],
+    )
+
+host_pass_through_polling_data = (
+    #----------------------------------------------------------------------------------------------------------------
+    #   OP     Reg                                 ValueToWrite        size    Test Expected Data           Description
+    #----------------------------------------------------------------------------------------------------------------
+    ["read", reg.PSU_HOST_DOORBELL_REG_WO_OR, 		"0", 		8, "0800000000000000", "Reading Host Doorbell for Interrupt Bit4"],
+    )
+
+
+#-------------------------
+# Main Function
+#-------------------------
+def main():
+    # Run Simics initially
+    testUtil.runCycles( 10000000 );
+
+    # Intialize the class obj instances
+    regObj = testPSUUtil.registry() # Registry obj def for operation
+
+    print "\n  Execute SBE Test - Set Pass through Address\n"
+
+    '''
+    Test Case 1
+    '''
+    # HOST->SBE data set execution
+    regObj.ExecuteTestOp( testPSUUtil.simSbeObj, sbe_test_data )
+
+    print "\n  Poll on Host side for INTR  ...\n"
+    #Poll on HOST DoorBell Register for interrupt
+    regObj.pollingOn( testPSUUtil.simSbeObj, host_polling_data, 5 )
+
+    #SBE->HOST data set execution
+    regObj.ExecuteTestOp( testPSUUtil.simSbeObj, host_test_data_success )
+
+    testUtil.runCycles( 10000000 )
+    # Put mem PBA - Passthrough
+    data = os.urandom(128*2)
+    data = [ord(c) for c in data]
+    # WO FMODE WO LCO PASSTHROUGH 
+    testMemUtil.putmem(0x00000000, data, 0x102)
+    #Poll on HOST DoorBell Register for interrupt
+    regObj.pollingOn( testPSUUtil.simSbeObj, host_pass_through_polling_data, 5 )
+    
+    readData = testMemUtil.getmem(0x00000000, 128*2, 0x102)
+    if(data == readData):
+        print ("Success - Write-Read PBA - With Pass through Mode")
+    else:
+        print data
+        print readData
+        raise Exception('data mistmach')
+    # Send an invalid size, it should fail
+    testMemUtil.getmem_failure(0x00000000, 128*4, 0x102, 0x0002000a)
+    print ("Success - Wrote an invalid size which failed")
+
+if __name__ == "__main__":
+    main()
+    if err:
+    	print ( "\nTest Suite completed with error(s)" )
+    	#sys.exit(1)
+    else:
+    	print ( "\nTest Suite completed with no errors" )
+	#sys.exit(0);
+
+
diff --git a/src/test/testcases/testPutGetMem.xml b/src/test/testcases/testPutGetMem.xml
index 8e87e3c5..5185ac10 100644
--- a/src/test/testcases/testPutGetMem.xml
+++ b/src/test/testcases/testPutGetMem.xml
@@ -28,3 +28,8 @@
           <simcmd>run-python-file targets/p9_nimbus/sbeTest/testMemPBA.py</simcmd>
           <exitonerror>yes</exitonerror>
       </testcase>
+      <testcase>
+          <simcmd>run-python-file targets/p9_nimbus/sbeTest/testPsuHostPassThrough.py</simcmd>
+          <exitonerror>yes</exitonerror>
+      </testcase>
+