Integration of hardware vpd accessor functions into Hostboot.

*Created macros and platform functions to invoke vpd accessor
functions for reading attributes from Hostboot.

*Create a unit test for calling each attribute accessor macro.

RTC: 178950
Change-Id: Ia74406eabcdff238f6bbc4bd8dc43715ebfcd643
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/48185
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
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: Prachi Gupta <pragupta@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

1 files changed, 628 insertions, 0 deletions

diff --git a/src/usr/fapi2/test/fapiGetMBVpdTest.H b/src/usr/fapi2/test/fapiGetMBVpdTest.H
new file mode 100644
index 000000000..87a7d89e9
--- /dev/null
+++ b/src/usr/fapi2/test/fapiGetMBVpdTest.H
@@ -0,0 +1,628 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/fapi2/test/fapiGetMBVpdTest.H $                       */
+/*                                                                        */
+/* OpenPOWER HostBoot 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                                                     */
+#ifndef __FAPI2_FAPI_GET_MB_VPD_TEST_H
+#define __FAPI2_FAPI_GET_MB_VPD_TEST_H
+
+#include <cxxtest/TestSuite.H>
+#include <attribute_service.H>
+
+#include <targeting/common/attributes.H>
+#include <fapi2/target.H>
+#include <target_types.H>
+
+#include <fapi2.H>
+
+// use TRACE_MB_VPD_ATTR_UNIT_TEST=1 make -j32
+// to enable tracing of unit test
+#ifdef TRACE_MB_VPD_ATTR_UNIT_TEST
+#define PRINT_VPD_INFO(str) \
+    FAPI_INF("%s", str)
+#define __TRACE_USE_ONLY__
+#define FAPI_TEST_TRACE(fmt, args...)\
+    FAPI_INF("Fapi2GetMBVpdTest::" fmt, ##args)
+#else
+#define __TRACE_USE_ONLY__ __attribute__((unused))
+#define PRINT_VPD_INFO(str)
+#define FAPI_TEST_TRACE(fmt, args...)
+#endif
+
+#define TEST_GET_ATTR(ID, TARGET) \
+if(rc)\
+{\
+    break;\
+}\
+do{\
+    FAPI_TEST_TRACE("TEST_GET_ATTR: Start Get Test For %s", #ID);\
+    ID##_Type buffer; \
+    clear_buffer(buffer); \
+    rc = FAPI_ATTR_GET(ID, TARGET, buffer);\
+    if(rc) \
+    {\
+        FAPI_TEST_TRACE("TEST_GET_ATTR: Failed to read %s", #ID);\
+        TS_FAIL("Fapi2GetMBVpdTest: Get Test Failed For Attribute %s", #ID); \
+    }\
+    else \
+    {\
+        dump_buffer(buffer, strbuffer, #ID); \
+        PRINT_VPD_INFO(strbuffer); \
+    }\
+}while(0)
+
+
+//----------------------------------------------------------------------
+class Fapi2GetMBVpdTest:public CxxTest::TestSuite
+{
+public:
+
+    //------------------------------------------------------------------
+    fapi2::ReturnCode hw_proc_for_test()
+    {
+        fapi2::ReturnCode rc{0};
+
+        do
+        {
+            char strbuffer[2048] = {0};
+
+            //getMBAttr attribute function.
+            TEST_GET_ATTR(ATTR_CEN_VPD_TSYS_ADR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_TSYS_DP18, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_RON, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_RTT_NOM, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_RTT_WR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_ODT_RD, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_ODT_WR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DIMM_RCD_IBT, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DIMM_RCD_OUTPUT_TIMING, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_RD_VREF, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_WR_VREF, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_WRDDR4_VREF, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_RCV_IMP_DQ_DQS, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRV_IMP_DQ_DQS, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRV_IMP_CNTL, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRV_IMP_ADDR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRV_IMP_CLK, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRV_IMP_SPCKE, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_SLEW_RATE_DQ_DQS, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_SLEW_RATE_CNTL, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_SLEW_RATE_ADDR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_SLEW_RATE_CLK, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_SLEW_RATE_SPCKE, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_CKE_PRI_MAP, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_CKE_PWR_MAP, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_RLO, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_WLO, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_GPO, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CLK_P0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CLK_P1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M1_CLK_P0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M1_CLK_P1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A2, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A3, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A4, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A5, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A6, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A7, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A8, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A9, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A10, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A11, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A12, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A13, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A14, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_A15, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_BA0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_BA1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_BA2, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_CASN, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_RASN, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_CMD_WEN, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_PAR, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M_ACTN, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CKE0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CKE1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CKE2, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CKE3, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CSN0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CSN1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CSN2, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_CSN3, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_ODT0, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_PHASE_ROT_M0_CNTL_ODT1, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_RTT_PARK, iv_targ_mba);
+            TEST_GET_ATTR(ATTR_CEN_VPD_RD_CTR_WINDAGE_OFFSET, iv_targ_mba);
+
+            TEST_GET_ATTR(ATTR_CEN_VPD_MR_VERSION_BYTE, iv_targ_membuf);
+            TEST_GET_ATTR(ATTR_CEN_VPD_MR_DATA_CONTROL_BYTE, iv_targ_membuf);
+            TEST_GET_ATTR(ATTR_CEN_VPD_MT_VERSION_BYTE, iv_targ_membuf);
+            TEST_GET_ATTR(ATTR_CEN_VPD_MT_DATA_CONTROL_BYTE, iv_targ_membuf);
+
+            //getControlCapableData attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_POWER_CONTROL_CAPABLE,
+                            iv_targ_membuf);
+
+            //getDQAttrISDIMM attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_ISDIMMTOC4DQ, iv_targ_membuf);
+
+            //getDQSAttrISDIMM attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_ISDIMMTOC4DQS, iv_targ_membuf);
+
+            //getMBvpdMemoryDataVersion attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_VM_KEYWORD, iv_targ_membuf);
+
+            //getMBvpdSPDXRecordVersion attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_VD_KEYWORD, iv_targ_membuf);
+
+            //getMBvpdVoltageSettingData attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_DW_KEYWORD, iv_targ_membuf);
+
+            //getMBvpdDram2NModeEnabled attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_DRAM_2N_MODE_ENABLED, iv_targ_mba);
+
+            //getMBvpdSpareDramData attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_DIMM_SPARE, iv_targ_mba);
+
+            //getMBvpdVersion attribute function
+            TEST_GET_ATTR(ATTR_CEN_VPD_VERSION, iv_targ_dimm);
+        }
+        while(0);
+
+        return rc;
+    }
+
+    //-----------------------------------------------------------------
+    void test_mb_vpd_attr()
+    {
+        errlHndl_t l_errl{};
+
+        do
+        {
+            if(not getTargets())
+            {
+                FAPI_INF("test_mb_vpd_attr: Skipping test, unable to populate "
+                        "targets. Assuming no memory buffers present.");
+                break;
+            }
+
+            //Tests placed in hardware proccedure for synchronization
+            FAPI_INVOKE_HWP(l_errl, hw_proc_for_test);
+        }
+        while(0);
+
+        if(not l_errl)
+        {
+            FAPI_INF("test_mb_vpd_attr: Exit Test Passed!");
+        }
+        else
+        {
+            delete l_errl;
+            FAPI_INF("test_mb_vpd_attr: Exit Test Failed!");
+        }
+    }
+
+private:
+
+    fapi2::Target<TARGET_TYPE_DIMM> iv_targ_dimm;
+    fapi2::Target<TARGET_TYPE_MBA> iv_targ_mba;
+    fapi2::Target<TARGET_TYPE_MEMBUF_CHIP> iv_targ_membuf;
+
+    //----------------------------------------------------
+    bool getTargets()
+    {
+        bool l_retval{false};
+
+        do
+        {
+            TARGETING::TargetHandleList l_membufTargetList;
+            TARGETING::getAllChips(l_membufTargetList,
+                                      TARGETING::TYPE_MEMBUF);
+
+            if(l_membufTargetList.empty())
+            {
+                FAPI_TEST_TRACE("getTargets: did not find any "
+                                                        "membuf targets.");
+                return l_retval;
+            }
+
+            for(TARGETING::Target* l_membufTarget: l_membufTargetList)
+            {
+                TARGETING::TargetHandleList l_mbaTargetList;
+                TARGETING::getChildChiplets(l_mbaTargetList,
+                                            l_membufTarget,
+                                            TARGETING::TYPE_MBA
+                                           );
+
+                for(TARGETING::Target* l_mbaTarget: l_mbaTargetList)
+                {
+                    TARGETING::Target* l_dimmTarget{};
+                    TARGETING::TargetHandleList l_dimmList;
+
+                    TARGETING::getChildAffinityTargets(
+                                                 l_dimmList,
+                                                 l_mbaTarget,
+                                                 TARGETING::CLASS_LOGICAL_CARD,
+                                                 TARGETING::TYPE_DIMM,
+                                                 false
+                                                      );
+
+                    for(TARGETING::Target* l_currentDimm: l_dimmList)
+                    {
+                        if(nullptr != l_currentDimm)
+                        {
+                            FAPI_TEST_TRACE("getTargets: Found a DIMM target "
+                                            "for the parent mba target.");
+
+                            l_dimmTarget = l_currentDimm;
+                            break;
+                        }
+                    }
+
+                    if(nullptr == l_dimmTarget)
+                    {
+                        FAPI_TEST_TRACE("getTargets: Failed to find a "
+                                        "DIMM child target from an MBA target"
+                                       );
+                        continue;
+                    }
+
+                    iv_targ_mba =
+                    fapi2::Target<fapi2::TARGET_TYPE_MBA>(l_mbaTarget);
+
+                    iv_targ_membuf =
+                    fapi2::Target<fapi2::TARGET_TYPE_MEMBUF_CHIP>
+                                                            (l_membufTarget);
+
+                    iv_targ_dimm =
+                    fapi2::Target<fapi2::TARGET_TYPE_DIMM>(l_dimmTarget);
+
+                    __TRACE_USE_ONLY__ TARGETING::ATTR_HUID_type l_huid = 0;
+
+                    l_huid = l_membufTarget->getAttr<TARGETING::ATTR_HUID>();
+                    FAPI_TEST_TRACE("getTargets: membuf huid: 0x%0X", l_huid);
+
+                    l_huid = l_mbaTarget->getAttr<TARGETING::ATTR_HUID>();
+                    FAPI_TEST_TRACE("getTargets: mba huid: 0x%0X", l_huid);
+
+                    l_huid = l_dimmTarget->getAttr<TARGETING::ATTR_HUID>();
+                    FAPI_TEST_TRACE("getTargets: dimm huid: 0x%0X", l_huid);
+
+                    l_retval = true;
+
+                    break;
+                }
+
+                if(l_retval)
+                {
+                    break;
+                }
+            }
+        }
+        while(0);
+
+        return l_retval;
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T>
+    bool dump_buffer_element(const T& i_arr,
+                             char*& io_ptr,
+                             size_t& io_remaining,
+                             size_t i_element_1)
+    {
+        bool l_retval{false};
+
+        do
+        {
+            int l_result = snprintf(io_ptr, io_remaining,
+                                     "\t[%llu]=0x%llX (%llu)\n",
+                                     i_element_1,
+                                     i_arr[i_element_1],
+                                     i_arr[i_element_1]
+                                     );
+
+            if(l_result >= 0 && static_cast<size_t>(l_result) <= io_remaining)
+            {
+                io_remaining -= static_cast<size_t>(l_result);
+                io_ptr += static_cast<size_t>(l_result);
+                l_retval = true;
+            }
+        }
+        while(0);
+
+        return l_retval;
+    }
+
+    //------------------------------------------------------------------------
+    template<typename T>
+    bool dump_buffer_element(const T& i_arr,
+                             char*& io_ptr,
+                             size_t& io_remaining,
+                             size_t i_element_1,
+                             size_t i_element_2)
+    {
+        bool l_retval{false};
+
+        do
+        {
+            int l_result = snprintf(io_ptr, io_remaining,
+                                 "\t[%llu][%llu]=0x%llX (%llu)\n",
+                                 i_element_1,
+                                 i_element_2,
+                                 i_arr[i_element_1][i_element_2],
+                                 i_arr[i_element_1][i_element_2]
+                                 );
+
+            if(l_result >= 0 && static_cast<size_t>(l_result) <= io_remaining)
+            {
+                io_remaining -= static_cast<size_t>(l_result);
+                io_ptr += static_cast<size_t>(l_result);
+                l_retval = true;
+            }
+        }
+        while(0);
+
+        return l_retval;
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T>
+    bool dump_buffer_element(const T& i_arr,
+                             char*& io_ptr,
+                             size_t& io_remaining,
+                             size_t i_element_1,
+                             size_t i_element_2,
+                             size_t i_element_3)
+    {
+        bool l_retval{false};
+
+        do
+        {
+            if(nullptr == io_ptr)
+            {
+                break;
+            }
+
+            int l_result = snprintf(io_ptr, io_remaining,
+                                 "\t[%llu][%llu][%llu]=0x%llX (%llu)\n",
+                                 i_element_1,
+                                 i_element_2,
+                                 i_element_3,
+                                 i_arr[i_element_1][i_element_2][i_element_3],
+                                 i_arr[i_element_1][i_element_2][i_element_3]);
+
+            if(l_result >= 0 && static_cast<size_t>(l_result) <= io_remaining)
+            {
+                io_remaining -= static_cast<size_t>(l_result);
+                io_ptr += static_cast<size_t>(l_result);
+                l_retval = true;
+            }
+        }
+        while(0);
+
+        return l_retval;
+    }
+
+    //-------------------------------------------------------------------------
+    bool dump_prefix(const char* i_prefix,
+                     char*& io_ptr,
+                     size_t& io_remaining)
+    {
+        bool l_retval{false};
+
+        do
+        {
+            int l_result = snprintf(io_ptr, io_remaining, "%s\n", i_prefix);
+            if(l_result >= 0 && static_cast<size_t>(l_result) <= io_remaining)
+            {
+                io_remaining -= static_cast<size_t>(l_result);
+                io_ptr += static_cast<size_t>(l_result);
+                l_retval = true;
+            }
+        }
+        while(0);
+
+        return l_retval;
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T, size_t N>
+    void dump_buffer(const T& i_arr,
+                     char (&i_strbuffer)[N],
+                     const char* i_prefix)
+    {
+        memset(i_strbuffer, 0, N);
+        char* l_ptr = i_strbuffer;
+        bool l_bResult{false};
+
+        do
+        {
+            size_t l_remaining{(N - 1)};
+
+            if(i_prefix)
+            {
+                l_bResult = dump_prefix(i_prefix ,l_ptr, l_remaining);
+                if(not l_bResult)
+                {
+                   break;
+                }
+            }
+
+            snprintf(l_ptr, l_remaining, "\tval=0x%llX\n", i_arr);
+        }
+        while(0);
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T>
+    void clear_buffer(T& i_arr)
+    {
+        memset(&i_arr, 0, sizeof(T));
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T, size_t I, size_t N>
+    void dump_buffer(const T (&i_arr)[I],
+                     char (&i_strbuffer)[N],
+                     const char* i_prefix)
+    {
+        memset(i_strbuffer, 0, N);
+        char* l_ptr = i_strbuffer;
+        bool l_bResult{false};
+
+        do
+        {
+            size_t l_remaining{(N - 1)};
+
+            if(i_prefix)
+            {
+                l_bResult = dump_prefix(i_prefix , l_ptr, l_remaining);
+                if(not l_bResult)
+                {
+                   break;
+                }
+            }
+
+            for(size_t i=0; i<I; ++i)
+            {
+                l_bResult = dump_buffer_element(i_arr, l_ptr, l_remaining, i);
+                if(not l_bResult)
+                {
+                    break;
+                }
+            }
+        }
+        while(0);
+    }
+
+    //----------------------------------------------------------------------
+    template<typename T, size_t I, size_t J, size_t N>
+    void dump_buffer(const T (&i_arr)[I][J],
+                    char (&i_strbuffer)[N],
+                    const char* i_prefix)
+    {
+        memset(i_strbuffer, 0, N);
+        char* l_ptr = i_strbuffer;
+
+        bool l_bResult{true};
+
+        do
+        {
+            size_t l_remaining{(N - 1)};
+
+            if(i_prefix)
+            {
+                l_bResult = dump_prefix(i_prefix , l_ptr, l_remaining);
+                if(not l_bResult)
+                {
+                   break;
+                }
+            }
+
+            for(size_t i=0; i<I; ++i)
+            {
+                for(size_t j=0; j<J; ++j)
+                {
+                    l_bResult = dump_buffer_element(i_arr,
+                                                    l_ptr,
+                                                    l_remaining,
+                                                    i,
+                                                    j);
+                    if(not l_bResult)
+                    {
+                       break;
+                    }
+                }
+
+                if(not l_bResult)
+                {
+                    break;
+                }
+            }
+
+        }
+        while(0);
+    }
+
+    //-------------------------------------------------------------------------
+    template<typename T,  size_t I, size_t J, size_t K, size_t N>
+    void dump_buffer(const T (&i_arr)[I][J][K],
+                     char (&i_strbuffer)[N],
+                     const char* i_prefix)
+    {
+        memset(i_strbuffer, 0, N);
+        char* l_ptr = i_strbuffer;
+
+        bool l_bResult{true};
+
+        do
+        {
+            size_t l_remaining{(N - 1)};
+
+            if(i_prefix)
+            {
+                l_bResult = dump_prefix(i_prefix, l_ptr, l_remaining);
+                if(not l_bResult)
+                {
+                   break;
+                }
+            }
+
+            for(size_t i=0; i<I; ++i)
+            {
+                for(size_t j=0; j<J; ++j)
+                {
+                    for(size_t k=0; k<K; ++k)
+                    {
+                        l_bResult = dump_buffer_element(i_arr,
+                                                        l_ptr,
+                                                        l_remaining,
+                                                        i,
+                                                        j,
+                                                        k);
+                        if(not l_bResult)
+                        {
+                           break;
+                        }
+                    }
+
+                    if(not l_bResult)
+                    {
+                        break;
+                    }
+                }
+
+                if(not l_bResult)
+                {
+                    break;
+                }
+            }
+        }
+        while(0);
+    }
+
+};
+
+#endif