/* adapter_global_eip97.c
 *
 * Security-IP-97 Global Control Adapter
 */

/*****************************************************************************
* 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 "api_global_eip97.h"
#include "adapter_global_internal.h"

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

// Default Adapter configuration
#include "c_adapter_global.h"

#ifndef GLOBALCONTROL_BUILD
#include "adapter_ring_eip202.h" // Ring EIP-202 interface to pass
                                 // config params from Global Control
#endif

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

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

// EIP-97 Driver Library Global Control API
#include "eip97_global_event.h" // Event Management
#include "eip97_global_init.h"  // Init/Uninit
#include "eip97_global_prng.h"  // PRNG Control

#include "device_types.h"       // Device_Handle_t
#include "device_mgmt.h"        // Device_find

// Logging API
#include "log.h"                // Log_*, LOG_*

#ifdef GLOBALCONTROL_BUILD
#include "shdevxs_init.h"       // SHDevXS_Global_init()
#endif

// Runtime Power Management Device Macros API
#include "rpm_device_macros.h"  // RPM_*


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

typedef struct
{
    bool fCached;

    GlobalControl97_Ring_PE_Map_t RingPEMap;

} GlobalControl97_Ring_PE_Map_Cache_t;

typedef struct
{
    bool fCached;

    GlobalControl97_PRNG_Reseed_t   ReseedData;

} GlobalControl97_PRNG_Cache_t;


/*----------------------------------------------------------------------------
 * Local variables
 */
static EIP97_Global_IOArea_t Global_IOArea;
static bool Global_IsInitialized;
static bool Global_PRNG_Present;

static const  GlobalControl97_Capabilities_t Global_CapabilitiesString =
{
  "EIP-97 v_._p_  with EIP-202 v_._p_ and EIP-96 v_._p_, "
  "#PE=__ #rings=__ central-prng=_"// szTextDescription
};

static unsigned int GlobalControl97_NofPEs;
static unsigned int GlobalControl97_NofRings;
static unsigned int GlobalControl97_NofLAInterfaces;
static unsigned int GlobalControl97_NofInlineInterfaces;

// Cached values for RPM resume callback
static GlobalControl97_Ring_PE_Map_Cache_t GlobalControl97_RingPEMap [ADAPTER_GLOBAL_EIP97_NOF_PES];
static GlobalControl97_PRNG_Cache_t GlobalControl97_Prng [ADAPTER_GLOBAL_EIP97_NOF_PES];


/*----------------------------------------------------------------------------
 * YesNo
 */
static const char *
YesNo(
        const bool b)
{
    if (b)
        return "Yes";
    else
        return "No";
}


/*----------------------------------------------------------------------------
 * GlobalControl97Lib_Resume
 *
 */
static int
GlobalControl97Lib_Resume(void * p)
{
    unsigned int i;
    EIP97_Global_Error_t rc;
    EIP97_Global_Capabilities_t Capabilities;

    IDENTIFIER_NOT_USED(p);

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

    rc = EIP97_Global_Init(&Global_IOArea,
                           Device_Find(ADAPTER_GLOBAL_DEVICE_NAME));
    if (rc != EIP97_GLOBAL_NO_ERROR)
    {
        LOG_CRIT("%s: EIP97_Global_Init() returned error %d\n", __func__, rc);
        return -1; // error
    }

    rc = EIP97_Global_HWRevision_Get(&Global_IOArea, &Capabilities);
    if (rc != EIP97_GLOBAL_NO_ERROR)
    {
        LOG_CRIT("%s: EIP97_Global_HWRevision_Get() returned error %d\n", __func__, rc);
        return -1; // error
    }
    GlobalControl97_NofPEs = MIN(Capabilities.EIP202_Options.NofPes, ADAPTER_GLOBAL_EIP97_NOF_PES);
    for (i = 0; i < GlobalControl97_NofPEs; i++)
    {
        if (GlobalControl97_RingPEMap[i].fCached)
        {
            LOG_INFO("\n\t\t\t\t EIP97_Global_Configure \n");

            rc = EIP97_Global_Configure(&Global_IOArea,
                                        i,
                                        &GlobalControl97_RingPEMap[i].RingPEMap);
            if (rc != EIP97_GLOBAL_NO_ERROR)
            {
                LOG_CRIT("%s: EIP97_Global_Configure() error %d for PE %d\n",
                         __func__,
                         rc,
                         i);
                return -2; // error
            }
        }

        if (GlobalControl97_Prng[i].fCached && Global_PRNG_Present)
        {
            LOG_INFO("\n\t\t\t\t EIP97_Global_PRNG_Reseed \n");

            rc = EIP97_Global_PRNG_Reseed(&Global_IOArea,
                                          i,
                                          &GlobalControl97_Prng[i].ReseedData);
            if (rc != EIP97_GLOBAL_NO_ERROR)
            {
                LOG_CRIT("%s: EIP97_Global_PRNG_Reseed() error %d for PE %d\n",
                         __func__,
                         rc,
                         i);
                return -3; // error
            }
        }
    } // for

    return 0; // success
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Capabilities_Get
 */
GlobalControl97_Error_t
GlobalControl97_Capabilities_Get(
        GlobalControl97_Capabilities_t * const Capabilities_p)
{
    uint8_t Versions[14];

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

    memcpy(Capabilities_p, &Global_CapabilitiesString,
           sizeof(Global_CapabilitiesString));

    {
        EIP97_Global_Error_t rc;
        EIP97_Global_Capabilities_t Capabilities;

        ZEROINIT(Capabilities);

        if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                RPM_FLAG_SYNC) != RPM_SUCCESS)
            return GLOBAL_CONTROL_ERROR_INTERNAL;

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

        rc = EIP97_Global_HWRevision_Get(&Global_IOArea, &Capabilities);

        (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                       RPM_FLAG_ASYNC);

        if (rc != EIP97_GLOBAL_NO_ERROR)
        {
            LOG_CRIT("GlobalControl97_Capabilities_Get: returned error");
            return GLOBAL_CONTROL_ERROR_INTERNAL;
        }

        // Show those capabilities not propagated to higher layer.
        LOG_CRIT("GlobalControl97_Capabilities_Get\n");
        LOG_CRIT("EIP202: PEs=%d rings=%d 64-bit=%s, fill level extension=%s\n"
                 "CF size=%d RF size=%d DMA len = %d "
                 "Align=%d HDW=%d HostIfc=%d\n",
                 Capabilities.EIP202_Options.NofPes,
                 Capabilities.EIP202_Options.NofRings,
                 YesNo(Capabilities.EIP202_Options.fAddr64),
                 YesNo(Capabilities.EIP202_Options.fExpPlf),
                 Capabilities.EIP202_Options.CF_Size,
                 Capabilities.EIP202_Options.RF_Size,
                 Capabilities.EIP202_Options.DMA_Len,
                 Capabilities.EIP202_Options.TgtAlign,
                 Capabilities.EIP202_Options.HDW,
                 Capabilities.EIP202_Options.HostIfc);
        LOG_CRIT("EIP96 options:\n"
                 "AES: %s with CFB/OFB: %s Fast: %s\n"
                 "DES: %s with CFB/OFB: %s Fast: %s\n"
                 "ARCFOUR level: %d\n"
                 "AES-XTS: %s Wireless crypto: %s\n"
                 "MD5: %s SHA1: %s Fast: %s SHA256: %s SHA512: %s\n"
                 "(X)CBC-MAC: %s Fast: %s All key sizes: %s GHASH %s\n",
                 YesNo(Capabilities.EIP96_Options.fAES),
                 YesNo(Capabilities.EIP96_Options.fAESfb),
                 YesNo(Capabilities.EIP96_Options.fAESspeed),
                 YesNo(Capabilities.EIP96_Options.fDES),
                 YesNo(Capabilities.EIP96_Options.fDESfb),
                 YesNo(Capabilities.EIP96_Options.fDESspeed),
                 Capabilities.EIP96_Options.ARC4,
                 YesNo(Capabilities.EIP96_Options.fAES_XTS),
                 YesNo(Capabilities.EIP96_Options.fWireless),
                 YesNo(Capabilities.EIP96_Options.fMD5),
                 YesNo(Capabilities.EIP96_Options.fSHA1),
                 YesNo(Capabilities.EIP96_Options.fSHA1speed),
                 YesNo(Capabilities.EIP96_Options.fSHA224_256),
                 YesNo(Capabilities.EIP96_Options.fSHA384_512),
                 YesNo(Capabilities.EIP96_Options.fXCBC_MAC),
                 YesNo(Capabilities.EIP96_Options.fCBC_MACspeed),
                 YesNo(Capabilities.EIP96_Options.fCBC_MACkeylens),
                 YesNo(Capabilities.EIP96_Options.fGHASH));
        LOG_CRIT("EIP97 options: PEs=%d, In Dbuf size=%d In Tbuf size=%d,"
                 " Out Dbuf size=%d, Out Tbuf size=%d, Central PRNG: %s\n"
                 "Token Generator: %s, Transform Record Cache: %s\n",
                 Capabilities.EIP97_Options.NofPes,
                 Capabilities.EIP97_Options.in_dbuf_size,
                 Capabilities.EIP97_Options.in_tbuf_size,
                 Capabilities.EIP97_Options.out_dbuf_size,
                 Capabilities.EIP97_Options.out_tbuf_size,
                 YesNo(Capabilities.EIP97_Options.central_prng),
                 YesNo(Capabilities.EIP97_Options.tg),
                 YesNo(Capabilities.EIP97_Options.trc));
        LOG_CRIT("EIP206 options: PE type=%d InClassifier=%d OutClassifier=%d "
                 "MAC chans=%d \n"
                 "InDBuf=%dkB InTBuf=%dkB OutDBuf=%dkB OutTBuf=%dkB\n",
                 Capabilities.EIP206_Options.PE_Type,
                 Capabilities.EIP206_Options.InClassifier,
                 Capabilities.EIP206_Options.OutClassifier,
                 Capabilities.EIP206_Options.NofMAC_Channels,
                 Capabilities.EIP206_Options.InDbufSizeKB,
                 Capabilities.EIP206_Options.InTbufSizeKB,
                 Capabilities.EIP206_Options.OutDbufSizeKB,
                 Capabilities.EIP206_Options.OutTbufSizeKB);

        Versions[0] = Capabilities.EIP97_Version.MajHWRevision;
        Versions[1] = Capabilities.EIP97_Version.MinHWRevision;
        Versions[2] = Capabilities.EIP97_Version.HWPatchLevel;

        Versions[3] = Capabilities.EIP202_Version.MajHWRevision;
        Versions[4] = Capabilities.EIP202_Version.MinHWRevision;
        Versions[5] = Capabilities.EIP202_Version.HWPatchLevel;

        Versions[6] = Capabilities.EIP96_Version.MajHWRevision;
        Versions[7] = Capabilities.EIP96_Version.MinHWRevision;
        Versions[8] = Capabilities.EIP96_Version.HWPatchLevel;

        Versions[9]  = Capabilities.EIP202_Options.NofPes / 10;
        Versions[10] = Capabilities.EIP202_Options.NofPes % 10;
        Versions[11] = Capabilities.EIP202_Options.NofRings / 10;
        Versions[12] = Capabilities.EIP202_Options.NofRings % 10;
        Versions[13] = (uint8_t)Capabilities.EIP97_Options.central_prng;
    }

    {
        char * p = Capabilities_p->szTextDescription;
        int VerIndex = 0;
        int i = 0;

        while(p[i])
        {
            if (p[i] == '_')
            {
                if (Versions[VerIndex] > 9)
                    p[i] = '?';
                else
                    p[i] = '0' + Versions[VerIndex];

                VerIndex++;
            }

            i++;
        }
    }

    return GLOBAL_CONTROL_NO_ERROR;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Init
 */
GlobalControl97_Error_t
GlobalControl97_Init(
        const bool fHWResetDone)
{
    EIP97_Global_Error_t rc;
    GlobalControl97_Error_t GC97_Rc = GLOBAL_CONTROL_ERROR_INTERNAL;
    Device_Handle_t dev;
    EIP97_Global_Capabilities_t Capabilities;

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

    if (Global_IsInitialized)
    {
        LOG_CRIT("GlobalControl97_Init: called while already initialized\n");
        return GLOBAL_CONTROL_ERROR_BAD_USE_ORDER;
    }

    dev = Device_Find(ADAPTER_GLOBAL_DEVICE_NAME);
    if (dev == NULL)
    {
        LOG_CRIT("GlobalControl97_Init: Could not find device\n");
        return GLOBAL_CONTROL_ERROR_INTERNAL;
    }

    ZEROINIT(GlobalControl97_RingPEMap);
    ZEROINIT(GlobalControl97_Prng);

    if (RPM_DEVICE_INIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                    NULL, // Suspend callback not used
                                    GlobalControl97Lib_Resume) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

    if (!fHWResetDone)
    {
        LOG_INFO("\n\t\t\t\t EIP97_Global_Reset \n");

        // Need to do a software reset first.
        rc = EIP97_Global_Reset(&Global_IOArea, dev);
        if (rc == EIP97_GLOBAL_BUSY_RETRY_LATER)
        {
            unsigned int tries = 0;
            do {
                LOG_INFO("\n\t\t\t\t EIP97_Global_Reset_IsDone \n");

                rc = EIP97_Global_Reset_IsDone(&Global_IOArea);
                if (rc != EIP97_GLOBAL_NO_ERROR &&
                    rc != EIP97_GLOBAL_BUSY_RETRY_LATER)
                {
                    LOG_CRIT("GlobalControl97_Init:"
                             " Error from EIP97_Global_Reset_IsDone\n");
                    goto exit; // error
                }
                tries ++;
                if (tries > ADAPTER_GLOBAL_RESET_MAX_RETRIES)
                {
                    LOG_CRIT("GlobalControl97_Init: Reset timeout\n");
                    goto exit; // error
                }
            } while (rc == EIP97_GLOBAL_BUSY_RETRY_LATER);
        }
        else if (rc != EIP97_GLOBAL_NO_ERROR)
        {
            LOG_CRIT("GlobalControl97_Init: Error from EIP97_Global_Reset\n");
            goto exit; // error
        }
    }

    ZEROINIT(Capabilities);

    rc = EIP97_Global_HWRevision_Get(&Global_IOArea, &Capabilities);
    if (rc != EIP97_GLOBAL_NO_ERROR)
    {
        LOG_CRIT("GlobalControl97_Init: returned error");
        goto exit; // error
    }
    Global_PRNG_Present = !Capabilities.EIP97_Options.central_prng;

    if (GlobalControl97Lib_Resume(NULL) != 0)
        goto exit; // error
    else
    {
        Global_IsInitialized = true;

        GlobalControl97_NofRings = Capabilities.EIP202_Options.NofRings;
        GlobalControl97_NofLAInterfaces = Capabilities.EIP202_Options2.NofLA_Ifs;
        GlobalControl97_NofInlineInterfaces = Capabilities.EIP202_Options2.NofIN_Ifs;

#ifdef GLOBALCONTROL_BUILD
        if (SHDevXS_Global_Init() != 0)
        {
            LOG_CRIT(
                "GlobalControl97_Init: SHDevXS_Global_Init() returned error");
            goto exit; // error
        }
#else
        // Pass HW default configuration parameters obtained via
        // the Global Control interface to the Ring Control
        // for its automatic configuration
        Adapter_Ring_EIP202_Configure(Capabilities.EIP202_Options.HDW,
                                      Capabilities.EIP202_Options.CF_Size,
                                      Capabilities.EIP202_Options.RF_Size);
#endif

        GC97_Rc = GLOBAL_CONTROL_NO_ERROR; // success
    }

exit:
    (void)RPM_DEVICE_INIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID);

    return GC97_Rc;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_UnInit
 */
GlobalControl97_Error_t
GlobalControl97_UnInit(void)
{
    EIP97_Global_Error_t rc;
    GlobalControl97_Error_t GC97_Rc = GLOBAL_CONTROL_ERROR_INTERNAL;
    Device_Handle_t dev;

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

    if (!Global_IsInitialized)
    {
        LOG_CRIT("GlobalControl97_UnInit: called while not initialized\n");
        return GLOBAL_CONTROL_ERROR_BAD_USE_ORDER;
    }

    dev = Device_Find(ADAPTER_GLOBAL_DEVICE_NAME);
    if (dev == NULL)
    {
        LOG_CRIT("GlobalControl97_UnInit: Could not find device\n");
        return GLOBAL_CONTROL_ERROR_INTERNAL;
    }

    if (RPM_DEVICE_UNINIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                      true) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_Reset(&Global_IOArea, dev);
    if (rc == EIP97_GLOBAL_BUSY_RETRY_LATER)
    {
        unsigned int tries = 0;
        do {
            LOG_INFO("\n\t\t\t\t EIP97_Global_Reset_IsDone \n");

            rc = EIP97_Global_Reset_IsDone(&Global_IOArea);
            if (rc != EIP97_GLOBAL_NO_ERROR &&
                rc != EIP97_GLOBAL_BUSY_RETRY_LATER)
            {
                LOG_CRIT("GlobalControl97_UnInit:"
                         " Error from EIP97_Global_Reset_IsDone\n");
                goto exit; // error
            }
                tries ++;
                if (tries > ADAPTER_GLOBAL_RESET_MAX_RETRIES)
                {
                    LOG_CRIT("GlobalControl97_UnInit: Reset timeout\n");
                    goto exit; // error
                }
        } while (rc == EIP97_GLOBAL_BUSY_RETRY_LATER);
    }
    else if (rc != EIP97_GLOBAL_NO_ERROR)
    {
        LOG_CRIT("GlobalControl97_Init: Error from EIP97_Global_Reset\n");
        goto exit; // error
    }

#ifdef GLOBALCONTROL_BUILD
    SHDevXS_Global_UnInit();
#endif

    Global_IsInitialized = false;

    GC97_Rc = GLOBAL_CONTROL_NO_ERROR; // success

exit:
    (void)RPM_DEVICE_UNINIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID);

    return GC97_Rc;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Configure
 */
GlobalControl97_Error_t
GlobalControl97_Configure(
        const unsigned int PE_Number,
        const GlobalControl97_Ring_PE_Map_t * const RingPEMap_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_Configure(&Global_IOArea, PE_Number, RingPEMap_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
    {
        // Fall back on EIP97_Global_Configure() for PE_Number bounds check
        GlobalControl97_RingPEMap[PE_Number].fCached   = true;
        GlobalControl97_RingPEMap[PE_Number].RingPEMap = *RingPEMap_p;
        return GLOBAL_CONTROL_NO_ERROR;
    }
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_PRNG_Reseed
 */
GlobalControl97_Error_t
GlobalControl97_PRNG_Reseed(
        const unsigned int PE_Number,
        const GlobalControl97_PRNG_Reseed_t * const ReseedData_p)
{
    EIP97_Global_Error_t rc;

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

    if (!Global_PRNG_Present)
    {
        LOG_CRIT("%s: PRNG device not present\n",__func__);
        return GLOBAL_CONTROL_ERROR_NOT_IMPLEMENTED;
    }

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_PRNG_Reseed(&Global_IOArea, PE_Number, ReseedData_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
    {
        GlobalControl97_Prng[PE_Number].fCached     = true;
        GlobalControl97_Prng[PE_Number].ReseedData  = *ReseedData_p;
        return GLOBAL_CONTROL_NO_ERROR;
    }
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;

}


/*----------------------------------------------------------------------------
 * GlobalControl97_DFE_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_DFE_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_DFE_Status_t * const DFE_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_DFE_Status_Get(&Global_IOArea, PE_Number, DFE_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_DSE_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_DSE_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_DSE_Status_t * const DSE_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_DSE_Status_Get(&Global_IOArea, PE_Number, DSE_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID, RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Token_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_Token_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_Token_Status_t * const Token_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_EIP96_Token_Status_Get(&Global_IOArea,
                                             PE_Number,
                                             Token_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Context_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_Context_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_Context_Status_t * const Context_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_EIP96_Context_Status_Get(&Global_IOArea,
                                               PE_Number,
                                               Context_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_Interrupt_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_Interrupt_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_Interrupt_Status_t * const Interrupt_Status_p)
{
    IDENTIFIER_NOT_USED(PE_Number);

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

    // Not implemented yet, must use EIP-96 AIC
    ZEROINIT(*Interrupt_Status_p);

    return GLOBAL_CONTROL_NO_ERROR;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_OutXfer_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_OutXfer_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_Output_Transfer_Status_t * const OutXfer_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_EIP96_OutXfer_Status_Get(&Global_IOArea,
                                               PE_Number,
                                               OutXfer_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}


/*----------------------------------------------------------------------------
 * GlobalControl97_PRNG_Status_Get
 */
GlobalControl97_Error_t
GlobalControl97_PRNG_Status_Get(
        const unsigned int PE_Number,
        GlobalControl97_PRNG_Status_t * const PRNG_Status_p)
{
    EIP97_Global_Error_t rc;

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

    if (!Global_PRNG_Present)
    {
        return GLOBAL_CONTROL_ERROR_NOT_IMPLEMENTED;
    }

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_EIP96_PRNG_Status_Get(&Global_IOArea,
                                            PE_Number,
                                            PRNG_Status_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                                   RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}

#ifdef ADAPTER_GLOBAL_DBG_STATISTICS
/*----------------------------------------------------------------------------
 * GlobalControl97_Debug_Statistics_Get
 */
GlobalControl97_Error_t
GlobalControl97_Debug_Statistics_Get(
        GlobalControl97_Debug_Statistics_t * const Debug_Statistics_p)
{
    EIP97_Global_Error_t rc;

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

    if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID,
                            RPM_FLAG_SYNC) != RPM_SUCCESS)
        return GLOBAL_CONTROL_ERROR_INTERNAL;

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

    rc = EIP97_Global_Debug_Statistics_Get(&Global_IOArea, Debug_Statistics_p);

    (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP97_DEVICE_ID, RPM_FLAG_ASYNC);

    if (rc == EIP97_GLOBAL_NO_ERROR)
        return GLOBAL_CONTROL_NO_ERROR;
    else if (rc == EIP97_GLOBAL_ARGUMENT_ERROR)
        return GLOBAL_CONTROL_ERROR_BAD_PARAMETER;
    else
        return GLOBAL_CONTROL_ERROR_INTERNAL;
}
#endif

/*----------------------------------------------------------------------------
 * GlobalControl97_Interfaces_Get
 */
void
GlobalControl97_Interfaces_Get(
    unsigned int * const NofPEs_p,
    unsigned int * const NofRings_p,
    unsigned int * const NofLAInterfaces_p,
    unsigned int * const NofInlineInterfaces_p)
{
    if (NofPEs_p)
        *NofPEs_p = GlobalControl97_NofPEs;
    if (NofRings_p)
        *NofRings_p = GlobalControl97_NofRings;
    if (NofLAInterfaces_p)
        *NofLAInterfaces_p = GlobalControl97_NofLAInterfaces;
    if (NofInlineInterfaces_p)
        *NofInlineInterfaces_p = GlobalControl97_NofInlineInterfaces;
}


/* end of file adapter_global_eip97.c */