/* adapter_global_cs_init.c
 *
 * Initialize Global Classification Control functionality.
 */

/*****************************************************************************
* Copyright (c) 2011-2021 by Rambus, Inc. and/or its subsidiaries.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/

/*----------------------------------------------------------------------------
 * This module implements (provides) the following interface(s):
 */

#include "adapter_global_cs_init.h"


/*----------------------------------------------------------------------------
 * This module uses (requires) the following interface(s):
 */

// Default configuration
#include "c_adapter_cs.h"

// Global Control API
#include "api_global_eip97.h"

// Global Control Classification API
#include "api_global_eip207.h"

// Driver Framework Basic Definitions API
#include "basic_defs.h"         // uint8_t, uint32_t, bool

// Driver Framework C Library API
#include "clib.h"               // memcpy, ZEROINIT

#include "device_types.h"       // Device_Handle_t
#include "device_mgmt.h"        // Device_find
#include "log.h"                // Log API


/*----------------------------------------------------------------------------
 * Definitions and macros
 */


/*----------------------------------------------------------------------------
 * Local variables
 */

static const uint32_t Global_IV_Data[4] = ADAPTER_CS_IV;


/*----------------------------------------------------------------------------
 * YesNo
 *
 * Convert boolean value to string.
 */
static const char *
YesNo(
        const bool b)
{
    if (b)
        return "YES";
    else
        return "no";
}


/*----------------------------------------------------------------------------
 * Adapter_Global_Cs_StatusReport()
 *
 * Obtain all available global status information from the Global Classification
 * hardware and report it.
 */
static void
Adapter_Global_Cs_StatusReport(void)
{
    GlobalControl207_Error_t rc;
    unsigned int i;
    unsigned int NofCEs;

    LOG_INFO("\n\t\t Adapter_Global_Cs_StatusReport \n");

    LOG_CRIT("Global Classification Control Status\n");
    GlobalControl97_Interfaces_Get(&NofCEs, NULL, NULL, NULL);

    for (i = 0; i < NofCEs; i++)
    {
        GlobalControl207_Status_t CE_Status;
        GlobalControl207_GlobalStats_t CE_GlobalStats;
        GlobalControl207_Clock_t CE_Clock;

        ZEROINIT(CE_Status);
        ZEROINIT(CE_GlobalStats);
        ZEROINIT(CE_Clock);

        LOG_CRIT("Classification Engine %d status\n", i);

        rc = GlobalControl207_Status_Get(i, &CE_Status);
        if (rc != EIP207_GLOBAL_CONTROL_NO_ERROR)
            LOG_CRIT("%s: GlobalControl207_Status_Get() failed\n", __func__);
        else
        {
            if (CE_Status.ICE.fPUE_EccCorr          ||
                CE_Status.ICE.fPUE_EccDerr          ||
                CE_Status.ICE.fFPP_EccCorr          ||
                CE_Status.ICE.fFPP_EccDerr          ||
                CE_Status.ICE.fTimerOverflow        ||
                CE_Status.OCE.fPUE_EccCorr          ||
                CE_Status.OCE.fPUE_EccDerr          ||
                CE_Status.OCE.fFPP_EccCorr          ||
                CE_Status.OCE.fFPP_EccDerr          ||
                CE_Status.OCE.fTimerOverflow        ||
                CE_Status.FLUE.Error1 != 0          ||
                CE_Status.FLUE.Error2 != 0          ||
                CE_Status.FRC[0].fDMAReadError      ||
                CE_Status.FRC[0].fDMAWriteError     ||
                CE_Status.FRC[0].fDataEccOflo       ||
                CE_Status.FRC[0].fDataEccErr        ||
                CE_Status.FRC[0].fAdminEccErr       ||
                CE_Status.TRC[0].fDMAReadError      ||
                CE_Status.TRC[0].fDMAWriteError     ||
                CE_Status.TRC[0].fDataEccOflo       ||
                CE_Status.TRC[0].fDataEccErr        ||
                CE_Status.TRC[0].fAdminEccErr       ||
                CE_Status.ARC4RC[0].fDMAReadError   ||
                CE_Status.ARC4RC[0].fDMAWriteError  ||
                CE_Status.ARC4RC[0].fDataEccOflo    ||
                CE_Status.ARC4RC[0].fDataEccErr     ||
                CE_Status.ARC4RC[0].fAdminEccErr)
            {
                LOG_CRIT("%s: error(s) detected\n", __func__);
                LOG_CRIT(
                 "\tICE Pull-Up ECC Correctable Err:        %s\n"
                 "\tICE Pull-Up ECC Non-Corr Err:           %s\n"
                 "\tICE Post-Processor ECC Correctable Err: %s\n"
                 "\tICE Post-Processor ECC Non-Corr Err:    %s\n"
                 "\tICE Timer ovf detected:                 %s\n"
                 "\tOCE Pull-Up ECC Correctable Err:        %s\n"
                 "\tOCE Pull-Up ECC Non-Corr Err:           %s\n"
                 "\tOCE Post-Processor ECC Correctable Err: %s\n"
                 "\tOCE Post-Processor ECC Non-Corr Err:    %s\n"
                 "\tOCE Timer ovf detected:                 %s\n"
                 "\tFLUE Err 1:                             %s (mask=0x%08x)\n"
                 "\tFLUE Err 2:                             %s (mask=0x%08x)\n"
                 "\tFRC#0 DMA Read Err:                     %s\n"
                 "\tFRC#0 DMA Write Err:                    %s\n"
                 "\tFRC#0 Data RAM ECC Non-Corr Ovf Err:    %s\n"
                 "\tFRC#0 Data RAM ECC Non-Corr Err:        %s\n"
                 "\tFRC#0 Admin RAM ECC Non-Corr Err:       %s\n"
                 "\tTRC#0 DMA Read Err:                     %s\n"
                 "\tTRC#0 DMA Write Err:                    %s\n"
                 "\tTRC#0 Data RAM ECC Non-Corr Ovf Err:    %s\n"
                 "\tTRC#0 Data RAM ECC Non-Corr Err:        %s\n"
                 "\tTRC#0 Admin RAM ECC Non-Corr Err:       %s\n"
                 "\tARC4RC#0 DMA Read Err:                  %s\n"
                 "\tARC4RC#0 DMA Write Err:                 %s\n"
                 "\tARC4RC#0 Data RAM ECC Non-Corr Ovf Err: %s\n"
                 "\tARC4RC#0 Data RAM ECC Non-Corr Err:     %s\n"
                 "\tARC4RC#0 Admin RAM ECC Non-Corr Err:    %s\n\n",
                 YesNo(CE_Status.ICE.fPUE_EccCorr),
                 YesNo(CE_Status.ICE.fPUE_EccDerr),
                 YesNo(CE_Status.ICE.fFPP_EccCorr),
                 YesNo(CE_Status.ICE.fFPP_EccDerr),
                 YesNo(CE_Status.ICE.fTimerOverflow),
                 YesNo(CE_Status.OCE.fPUE_EccCorr),
                 YesNo(CE_Status.OCE.fPUE_EccDerr),
                 YesNo(CE_Status.OCE.fFPP_EccCorr),
                 YesNo(CE_Status.OCE.fFPP_EccDerr),
                 YesNo(CE_Status.OCE.fTimerOverflow),
                 YesNo(CE_Status.FLUE.Error1 != 0),
                 CE_Status.FLUE.Error1,
                 YesNo(CE_Status.FLUE.Error2 != 0),
                 CE_Status.FLUE.Error2,
                 YesNo(CE_Status.FRC[0].fDMAReadError),
                 YesNo(CE_Status.FRC[0].fDMAWriteError),
                 YesNo(CE_Status.FRC[0].fDataEccOflo),
                 YesNo(CE_Status.FRC[0].fDataEccErr),
                 YesNo(CE_Status.FRC[0].fAdminEccErr),
                 YesNo(CE_Status.TRC[0].fDMAReadError),
                 YesNo(CE_Status.TRC[0].fDMAWriteError),
                 YesNo(CE_Status.TRC[0].fDataEccOflo),
                 YesNo(CE_Status.TRC[0].fDataEccErr),
                 YesNo(CE_Status.TRC[0].fAdminEccErr),
                 YesNo(CE_Status.ARC4RC[0].fDMAReadError),
                 YesNo(CE_Status.ARC4RC[0].fDMAWriteError),
                 YesNo(CE_Status.ARC4RC[0].fDataEccOflo),
                 YesNo(CE_Status.ARC4RC[0].fDataEccErr),
                 YesNo(CE_Status.ARC4RC[0].fAdminEccErr));
            }
            else
                LOG_CRIT("%s: all OK\n", __func__);
            if (CE_Status.FRCStats[0].PrefetchExec ||
                CE_Status.FRCStats[0].PrefetchBlock ||
                CE_Status.FRCStats[0].PrefetchDMA ||
                CE_Status.FRCStats[0].SelectOps ||
                CE_Status.FRCStats[0].SelectDMA ||
                CE_Status.FRCStats[0].IntDMAWrite ||
                CE_Status.FRCStats[0].ExtDMAWrite ||
                CE_Status.FRCStats[0].InvalidateOps)
            {
                LOG_CRIT("FRC statistics:\n"
                         "\tPrefetches executed: %u\n"
                         "\tPrefetches blocked:  %u\n"
                         "\tPrefetches with DMA: %u\n"
                         "\tSelect ops:          %u\n"
                         "\tSelect ops with DMA: %u\n"
                         "\tInternal DMA writes: %u\n"
                         "\tExternal DMA writes: %u\n"
                         "\tInvalidate ops:      %u\n"
                         "\tDMA err flags        0x%x\n"
                         "\tRead DMA errs:       %u\n"
                         "\tWrite DMA errs:      %u\n"
                         "\tECC invalidates:     %u\n"
                         "\tECC Data RAM Corr:   %u\n"
                         "\tECC Admin RAM Corr:  %u\n",
                         (uint32_t)CE_Status.FRCStats[0].PrefetchExec,
                         (uint32_t)CE_Status.FRCStats[0].PrefetchBlock,
                         (uint32_t)CE_Status.FRCStats[0].PrefetchDMA,
                         (uint32_t)CE_Status.FRCStats[0].SelectOps,
                         (uint32_t)CE_Status.FRCStats[0].SelectDMA,
                         (uint32_t)CE_Status.FRCStats[0].IntDMAWrite,
                         (uint32_t)CE_Status.FRCStats[0].ExtDMAWrite,
                         (uint32_t)CE_Status.FRCStats[0].InvalidateOps,
                         (uint32_t)CE_Status.FRCStats[0].ReadDMAErrFlags,
                         (uint32_t)CE_Status.FRCStats[0].ReadDMAErrors,
                         (uint32_t)CE_Status.FRCStats[0].WriteDMAErrors,
                         (uint32_t)CE_Status.FRCStats[0].InvalidateECC,
                         (uint32_t)CE_Status.FRCStats[0].DataECCCorr,
                         (uint32_t)CE_Status.FRCStats[0].AdminECCCorr);
            }
            if (CE_Status.TRCStats[0].PrefetchExec ||
                CE_Status.TRCStats[0].PrefetchBlock ||
                CE_Status.TRCStats[0].PrefetchDMA ||
                CE_Status.TRCStats[0].SelectOps ||
                CE_Status.TRCStats[0].SelectDMA ||
                CE_Status.TRCStats[0].IntDMAWrite ||
                CE_Status.TRCStats[0].ExtDMAWrite ||
                CE_Status.TRCStats[0].InvalidateOps)
            {
                LOG_CRIT("TRC statistics:\n"
                         "\tPrefetches executed: %u\n"
                         "\tPrefetches blocked:  %u\n"
                         "\tPrefetches with DMA: %u\n"
                         "\tSelect ops:          %u\n"
                         "\tSelect ops with DMA: %u\n"
                         "\tInternal DMA writes: %u\n"
                         "\tExternal DMA writes: %u\n"
                         "\tInvalidate ops:      %u\n"
                         "\tDMA err flags        0x%x\n"
                         "\tRead DMA errs:       %u\n"
                         "\tWrite DMA errs:      %u\n"
                         "\tECC invalidates:     %u\n"
                         "\tECC Data RAM Corr:   %u\n"
                         "\tECC Admin RAM Corr:  %u\n",
                         (uint32_t)CE_Status.TRCStats[0].PrefetchExec,
                         (uint32_t)CE_Status.TRCStats[0].PrefetchBlock,
                         (uint32_t)CE_Status.TRCStats[0].PrefetchDMA,
                         (uint32_t)CE_Status.TRCStats[0].SelectOps,
                         (uint32_t)CE_Status.TRCStats[0].SelectDMA,
                         (uint32_t)CE_Status.TRCStats[0].IntDMAWrite,
                         (uint32_t)CE_Status.TRCStats[0].ExtDMAWrite,
                         (uint32_t)CE_Status.TRCStats[0].InvalidateOps,
                         (uint32_t)CE_Status.TRCStats[0].ReadDMAErrFlags,
                         (uint32_t)CE_Status.TRCStats[0].ReadDMAErrors,
                         (uint32_t)CE_Status.TRCStats[0].WriteDMAErrors,
                         (uint32_t)CE_Status.TRCStats[0].InvalidateECC,
                         (uint32_t)CE_Status.TRCStats[0].DataECCCorr,
                         (uint32_t)CE_Status.TRCStats[0].AdminECCCorr);
            }
        }

        rc = GlobalControl207_GlobalStats_Get(i, &CE_GlobalStats);
        if (rc != EIP207_GLOBAL_CONTROL_NO_ERROR)
            LOG_CRIT("Adapter_Global_Cs_StatusReport: "
                     "GlobalControl207_GlobalStats_Get() failed\n");
        else
            LOG_CRIT(
                 "\tICE Dropped Packets Counter (low 32-bits):     0x%08x\n"
                 "\tICE Dropped Packets Counter (high 32-bits):    0x%08x\n"
                 "\tICE Inbound Packets Counter:                   0x%08x\n"
                 "\tICE Outbound Packets Counter:                  0x%08x\n"
                 "\tICE Inbound Octets Counter (low 32-bits):      0x%08x\n"
                 "\tICE Inbound Octets Counter (high 32-bits):     0x%08x\n"
                 "\tICE Outbound Octets Counter (low 32-bits):     0x%08x\n"
                 "\tICE Outbound Octets Counter (high 32-bits):    0x%08x\n"
                 "\tOCE Dropped Packets Counter (low 32-bits):     0x%08x\n"
                 "\tOCE Dropped Packets Counter (high 32-bits):    0x%08x\n\n",
                 CE_GlobalStats.ICE.DroppedPacketsCounter.Value64_Lo,
                 CE_GlobalStats.ICE.DroppedPacketsCounter.Value64_Hi,
                 CE_GlobalStats.ICE.InboundPacketsCounter,
                 CE_GlobalStats.ICE.OutboundPacketCounter,
                 CE_GlobalStats.ICE.InboundOctetsCounter.Value64_Lo,
                 CE_GlobalStats.ICE.InboundOctetsCounter.Value64_Hi,
                 CE_GlobalStats.ICE.OutboundOctetsCounter.Value64_Lo,
                 CE_GlobalStats.ICE.OutboundOctetsCounter.Value64_Hi,
                 CE_GlobalStats.OCE.DroppedPacketsCounter.Value64_Lo,
                 CE_GlobalStats.OCE.DroppedPacketsCounter.Value64_Hi);

        rc = GlobalControl207_ClockCount_Get(i, &CE_Clock);
        if (rc != EIP207_GLOBAL_CONTROL_NO_ERROR)
            LOG_CRIT("Adapter_Global_Cs_StatusReport: "
                     "GlobalControl207_ClockCount_Get() failed\n");
        else
            LOG_CRIT(
                 "\tICE Clock Count (low 32-bits):   0x%08x\n"
                 "\tICE Clock Count (high 32-bits):  0x%08x\n"
                 "\tOCE Clock Count (low 32-bits):   0x%08x\n"
                 "\tOCE Clock Count (high 32-bits):  0x%08x\n\n",
                 CE_Clock.ICE.Value64_Lo,
                 CE_Clock.ICE.Value64_Hi,
                 CE_Clock.OCE.Value64_Lo,
                 CE_Clock.OCE.Value64_Hi);
    } // for
}


/*----------------------------------------------------------------------------
 * Adapter_Global_Cs_Init()
 *
 */
bool
Adapter_Global_Cs_Init(void)
{
    GlobalControl207_Error_t rc;
    GlobalControl207_Capabilities_t Capabilities;
    GlobalControl207_IV_t Data;

    LOG_INFO("\n\t\t Adapter_Global_Cs_Init \n");

    Data.IV[0] = Global_IV_Data[0];
    Data.IV[1] = Global_IV_Data[1];
    Data.IV[2] = Global_IV_Data[2];
    Data.IV[3] = Global_IV_Data[3];

    // Request the classification firmware download during the initialization
    rc = GlobalControl207_Init(true, &Data);
    if (rc != EIP207_GLOBAL_CONTROL_NO_ERROR)
    {
        LOG_CRIT("Adaptar_Global_Init: Classification initialization failed\n");
        return false;
    }

    Capabilities.szTextDescription[0] = 0;

    GlobalControl207_Capabilities_Get(&Capabilities);

    LOG_CRIT("Global Classification capabilities: %s\n",
             Capabilities.szTextDescription);

    Adapter_Global_Cs_StatusReport();

    return true;
}


/*----------------------------------------------------------------------------
 * Adapter_Global_Cs_UnInit()
 *
 */
void
Adapter_Global_Cs_UnInit(void)
{
    LOG_INFO("\n\t\t Adapter_Global_Cs_UnInit \n");

    Adapter_Global_Cs_StatusReport();

    GlobalControl207_UnInit();
}


/* end of file adapter_global_cs_init.c */