| /* adapter_global_eip207.c |
| * |
| * Security-IP-207 Global Control Adapter |
| */ |
| |
| /***************************************************************************** |
| * Copyright (c) 2011-2022 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): |
| */ |
| |
| // Classification (EIP-207) Global Control Initialization API |
| #include "api_global_eip207.h" |
| |
| // Classification (EIP-207) Global Control Status API |
| #include "api_global_status_eip207.h" |
| |
| |
| /*---------------------------------------------------------------------------- |
| * This module uses (requires) the following interface(s): |
| */ |
| #include "c_adapter_cs.h" |
| |
| #ifndef GLOBALCONTROL_BUILD |
| #include "adapter_rc_eip207.h" // Record Cache EIP-207 interface to pass |
| // config params from Global Control |
| #endif |
| |
| // Global Control API |
| #include "api_global_eip97.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 |
| |
| // EIP-207 Driver Library Global Control API |
| #include "eip207_global_init.h" // Init/Uninit/Status/FW download |
| |
| // EIP-207 Driver Library Global Control API: Configuration |
| #include "eip207_global_config.h" // EIP207_Global_MetaData_Configure |
| |
| #include "device_types.h" // Device_Handle_t |
| #include "device_mgmt.h" // Device_find |
| |
| // Logging API |
| #include "log.h" // Log_*, LOG_* |
| |
| // Firmware load API. |
| #include "adapter_firmware.h" |
| #include "firmware_eip207_api_dwld.h" |
| |
| // Runtime Power Management Device Macros API |
| #include "rpm_device_macros.h" // RPM_* |
| |
| // EIP97_Supported_Funcs_Get() |
| #include "eip97_global_init.h" |
| |
| |
| /*---------------------------------------------------------------------------- |
| * Definitions and macros |
| */ |
| |
| /* Support legacy firmware packages without name parameters in download API */ |
| #ifndef FIRMWARE_EIP207_IPUE_NAME |
| #define FIRMWARE_EIP207_IPUE_NAME "firmware_eip207_ipue.bin" |
| #define FIRMWARE_EIP207_IFPP_NAME "firmware_eip207_ifpp.bin" |
| #endif |
| #ifndef FIRMWARE_EIP207_OPUE_NAME |
| #define FIRMWARE_EIP207_OPUE_NAME "firmware_eip207_opue.bin" |
| #define FIRMWARE_EIP207_OFPP_NAME "firmware_eip207_ofpp.bin" |
| #endif |
| |
| /*---------------------------------------------------------------------------- |
| * Local variables |
| */ |
| |
| static EIP207_Global_IOArea_t Global_IOArea; |
| static bool Global_IsInitialized; |
| |
| // Cached values during initialization will be used for RPM device resume |
| static EIP207_Global_CacheConfig_t RC_Conf; |
| static EIP207_Global_FLUEConfig_t FLUE_Conf; |
| |
| static const GlobalControl207_Capabilities_t Global_CapabilitiesString = |
| { |
| "EIP-207 v_._p_ #cache sets=__ #lookup tables=__" // szTextDescription |
| }; |
| |
| |
| /*---------------------------------------------------------------------------- |
| * YesNo |
| */ |
| static const char * |
| YesNo( |
| const bool b) |
| { |
| if (b) |
| return "Yes"; |
| else |
| return "No"; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207Lib_Init |
| * |
| */ |
| static int |
| GlobalControl207Lib_Init(void) |
| { |
| EIP207_Global_Error_t rc; |
| unsigned int i; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_Init \n"); |
| |
| rc = EIP207_Global_Init(&Global_IOArea, |
| Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME), |
| &RC_Conf, |
| &FLUE_Conf); |
| |
| for (i = 0; i < EIP207_GLOBAL_MAX_NOF_CACHE_SETS_TO_USE; i++) |
| { |
| Log_FormattedMessage("GlobalControl_EIP207_Init cache set %d:\n" |
| "\t\tFRC AdminWords=%5d DataWords=%5d\n" |
| "\t\tTRC AdminWords=%5d DataWords=%5d\n" |
| "\t\tARC4 AdminWords=%5d DataWords=%5d\n", |
| i, |
| RC_Conf.FRC[i].AdminWordCount, |
| RC_Conf.FRC[i].DataWordCount, |
| RC_Conf.TRC[i].AdminWordCount, |
| RC_Conf.TRC[i].DataWordCount, |
| RC_Conf.ARC4[i].AdminWordCount, |
| RC_Conf.ARC4[i].DataWordCount); |
| } |
| |
| if (rc != EIP207_GLOBAL_NO_ERROR) |
| { |
| LOG_CRIT("%s: EIP207_Global_Init() returned error %d\n", __func__, rc); |
| return -1; // error |
| } |
| |
| return 0; // success |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207Lib_Firmware_Load |
| * |
| */ |
| static int |
| GlobalControl207Lib_Firmware_Load(bool fVerbose) |
| { |
| Adapter_Firmware_t IPUE_Handle, IFPP_Handle,OPUE_Handle, OFPP_Handle; |
| EIP207_Firmware_t IPUE_Firmware, IFPP_Firmware; |
| EIP207_Firmware_t OPUE_Firmware, OFPP_Firmware; |
| EIP207_Global_Error_t rc; |
| |
| ZEROINIT(IPUE_Firmware); |
| ZEROINIT(IFPP_Firmware); |
| ZEROINIT(OPUE_Firmware); |
| ZEROINIT(OFPP_Firmware); |
| |
| #ifdef FIRMWARE_EIP207_VERSION_MAJOR |
| // If version numbers are provided, then fill them in, so they |
| // will be checked against the actual firmware, else leave them |
| // at zero. |
| IPUE_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| IPUE_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| IPUE_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| IFPP_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| IFPP_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| IFPP_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| OPUE_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| OPUE_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| OPUE_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| OFPP_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| OFPP_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| OFPP_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| #endif |
| IPUE_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_IPUE_NAME, |
| &IPUE_Firmware.Image_p, |
| &IPUE_Firmware.ImageWordCount); |
| IFPP_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_IFPP_NAME, |
| &IFPP_Firmware.Image_p, |
| &IFPP_Firmware.ImageWordCount); |
| if ((EIP97_SupportedFuncs_Get() & BIT_1) != 0) |
| { |
| OPUE_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_OPUE_NAME, |
| &OPUE_Firmware.Image_p, |
| &OPUE_Firmware.ImageWordCount); |
| OFPP_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_OFPP_NAME, |
| &OFPP_Firmware.Image_p, |
| &OFPP_Firmware.ImageWordCount); |
| } |
| else |
| { |
| OPUE_Handle = Adapter_Firmware_NULL; |
| OFPP_Handle = Adapter_Firmware_NULL; |
| } |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_Firmware_Load \n"); |
| |
| rc = EIP207_Global_Firmware_Load(&Global_IOArea, |
| ADAPTER_CS_TIMER_PRESCALER, |
| &IPUE_Firmware, |
| &IFPP_Firmware, |
| &OPUE_Firmware, |
| &OFPP_Firmware); |
| Adapter_Firmware_Release(IPUE_Handle); |
| Adapter_Firmware_Release(IFPP_Handle); |
| Adapter_Firmware_Release(OPUE_Handle); |
| Adapter_Firmware_Release(OFPP_Handle); |
| if (rc != EIP207_GLOBAL_NO_ERROR) |
| { |
| LOG_CRIT("GlobalControl207_Init: " |
| "EIP207_Global_Firmware_Load() failed\n"); |
| return -3; // error |
| } |
| else if (fVerbose) |
| { |
| LOG_CRIT("GlobalControl207_Init: firmware " |
| "downloaded successfully\n"); |
| |
| LOG_CRIT("\tIPUE firmware v%d.%d.%d, image byte count %d\n", |
| IPUE_Firmware.Major, |
| IPUE_Firmware.Minor, |
| IPUE_Firmware.PatchLevel, |
| (int)(IPUE_Firmware.ImageWordCount * sizeof(uint32_t))); |
| |
| LOG_CRIT("\tIFPP firmware v%d.%d.%d, image byte count %d\n\n", |
| IFPP_Firmware.Major, |
| IFPP_Firmware.Minor, |
| IFPP_Firmware.PatchLevel, |
| (int)(IFPP_Firmware.ImageWordCount * sizeof(uint32_t))); |
| |
| LOG_CRIT("\tOPUE firmware v%d.%d.%d, image byte count %d\n", |
| OPUE_Firmware.Major, |
| OPUE_Firmware.Minor, |
| OPUE_Firmware.PatchLevel, |
| (int)(OPUE_Firmware.ImageWordCount * sizeof(uint32_t))); |
| |
| LOG_CRIT("\tOFPP firmware v%d.%d.%d, image byte count %d\n\n", |
| OFPP_Firmware.Major, |
| OFPP_Firmware.Minor, |
| OFPP_Firmware.PatchLevel, |
| (int)(OFPP_Firmware.ImageWordCount * sizeof(uint32_t))); |
| } |
| return 0; |
| } |
| |
| #ifdef ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207Lib_Resume |
| * |
| */ |
| static int |
| GlobalControl207Lib_Resume(void * p) |
| { |
| EIP207_Global_Error_t rc; |
| EIP207_Firmware_t IPUE_Firmware, IFPP_Firmware; |
| EIP207_Firmware_t OPUE_Firmware, OFPP_Firmware; |
| |
| IDENTIFIER_NOT_USED(p); |
| |
| if (GlobalControl207Lib_Init() != 0) |
| return -1; // error |
| |
| if (GlobalControl207Lib_Firmware_Load(false) != 0) |
| return -2; // error |
| |
| return 0; // success |
| } |
| #endif |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_Capabilities_Get |
| */ |
| void |
| GlobalControl207_Capabilities_Get( |
| GlobalControl207_Capabilities_t * const Capabilities_p) |
| { |
| uint8_t Versions[7]; |
| |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| memcpy(Capabilities_p, &Global_CapabilitiesString, |
| sizeof(Global_CapabilitiesString)); |
| |
| { |
| EIP207_Global_Error_t rc; |
| EIP207_Global_Capabilities_t Capabilities; |
| |
| if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_SYNC) != RPM_SUCCESS) |
| return; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_HWRevision_Get \n"); |
| |
| rc = EIP207_Global_HWRevision_Get(&Global_IOArea, &Capabilities); |
| |
| (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_ASYNC); |
| |
| if (rc != EIP207_GLOBAL_NO_ERROR) |
| { |
| LOG_CRIT("GlobalControl207_Capabilities_Get: " |
| "EIP207_Global_HWRevision_Get() failed\n"); |
| return; |
| } |
| |
| // Show those capabilities not propagated to higher layer. |
| LOG_CRIT("EIP-207 capabilities\n"); |
| LOG_CRIT("\tLookup cached: %s\n" |
| "\tFRC combined with TRC: %s\n" |
| "\tARC4RC present: %s\n" |
| "\tFRC combined with ARC4RC: %s\n" |
| "\tTRC combined with ARC4RC: %s\n" |
| "\tFRC clients: %d\n" |
| "\tTRC clients: %d\n" |
| "\tARC4RC clients: %d\n" |
| "\tLookup clients: %d\n\n", |
| YesNo(Capabilities.EIP207_Options.fLookupCached), |
| YesNo(Capabilities.EIP207_Options.fCombinedFRC_TRC), |
| YesNo(Capabilities.EIP207_Options.fARC4Present), |
| YesNo(Capabilities.EIP207_Options.fCombinedFRC_ARC4), |
| YesNo(Capabilities.EIP207_Options.fCombinedTRC_ARC4), |
| Capabilities.EIP207_Options.NofFRC_Clients, |
| Capabilities.EIP207_Options.NofTRC_Clients, |
| Capabilities.EIP207_Options.NofARC4_Clients, |
| Capabilities.EIP207_Options.NofLookupClients); |
| |
| Versions[0] = Capabilities.EIP207_Version.MajHWRevision; |
| Versions[1] = Capabilities.EIP207_Version.MinHWRevision; |
| Versions[2] = Capabilities.EIP207_Version.HWPatchLevel; |
| |
| Versions[3] = Capabilities.EIP207_Options.NofCacheSets / 10; |
| Versions[4] = Capabilities.EIP207_Options.NofCacheSets % 10; |
| |
| Versions[5] = Capabilities.EIP207_Options.NofLookupTables / 10; |
| Versions[6] = Capabilities.EIP207_Options.NofLookupTables % 10; |
| } |
| |
| { |
| 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++]; |
| |
| if (VerIndex >= 7) |
| break; |
| } |
| |
| i++; |
| } |
| } |
| |
| return; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_Init |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_Init( |
| const bool fLoadFirmware, |
| const GlobalControl207_IV_t * const IV_p) |
| { |
| unsigned int i; |
| GlobalControl207_Error_t GC207_Rc = EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| EIP207_Global_Error_t rc; |
| Device_Handle_t Device; |
| unsigned int NofCEs,NofRings,NofLAInterfaces,NofInlineInterfaces; |
| |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| if (Global_IsInitialized) |
| { |
| LOG_CRIT("GlobalControl207_Init: called while already initialized\n"); |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_USE_ORDER; |
| } |
| |
| Device = Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME); |
| if (Device == NULL) |
| { |
| LOG_CRIT("GlobalControl207_Init: Could not find device\n"); |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| } |
| |
| ZEROINIT(RC_Conf); |
| ZEROINIT(FLUE_Conf); |
| |
| // Record Caches initialization parameters |
| for (i = 0; i < EIP207_GLOBAL_MAX_NOF_CACHE_SETS_TO_USE; i++) |
| { |
| RC_Conf.FRC[i].fEnable = (ADAPTER_CS_FRC_ENABLED != 0); |
| RC_Conf.FRC[i].fNonBlock = false; |
| RC_Conf.FRC[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| RC_Conf.FRC[i].RecBaseAddr.Value64_Lo = 0; |
| RC_Conf.FRC[i].RecBaseAddr.Value64_Hi = 0; |
| |
| RC_Conf.TRC[i].fEnable = (ADAPTER_CS_TRC_ENABLED != 0); |
| RC_Conf.TRC[i].fNonBlock = false; |
| RC_Conf.TRC[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| RC_Conf.TRC[i].RecBaseAddr.Value64_Lo = 0; |
| RC_Conf.TRC[i].RecBaseAddr.Value64_Hi = 0; |
| |
| RC_Conf.ARC4[i].fEnable = (ADAPTER_CS_ARC4RC_ENABLED != 0); |
| RC_Conf.ARC4[i].fNonBlock = false; |
| RC_Conf.ARC4[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| RC_Conf.ARC4[i].RecBaseAddr.Value64_Lo = 0; |
| RC_Conf.ARC4[i].RecBaseAddr.Value64_Hi = 0; |
| } |
| |
| // Flow Look-Up Engine initialization parameters |
| FLUE_Conf.CacheChain = ADAPTER_CS_FLUE_CACHE_CHAIN; |
| FLUE_Conf.fDelayMemXS = (ADAPTER_CS_FLUE_MEMXS_DELAY != 0); |
| FLUE_Conf.IV.IV_Word32[0] = IV_p->IV[0]; |
| FLUE_Conf.IV.IV_Word32[1] = IV_p->IV[1]; |
| FLUE_Conf.IV.IV_Word32[2] = IV_p->IV[2]; |
| FLUE_Conf.IV.IV_Word32[3] = IV_p->IV[3]; |
| |
| // Hash table initialization parameters |
| FLUE_Conf.HashTablesCount = ADAPTER_CS_MAX_NOF_FLOW_HASH_TABLES_TO_USE; |
| for (i = 0; i < FLUE_Conf.HashTablesCount; i++) |
| { |
| FLUE_Conf.HashTable[i].fLookupCached = |
| (ADAPTER_CS_FLUE_LOOKUP_CACHED != 0); |
| FLUE_Conf.HashTable[i].fPrefetchXform = |
| (ADAPTER_CS_FLUE_PREFETCH_XFORM != 0); |
| FLUE_Conf.HashTable[i].fPrefetchARC4State = |
| (ADAPTER_CS_FLUE_PREFETCH_ARC4 != 0); |
| } |
| |
| GlobalControl97_Interfaces_Get(&NofCEs, &NofRings, &NofLAInterfaces, &NofInlineInterfaces); |
| LOG_CRIT("GlobalControl_EIP207_Init:\n" |
| "Number of Rings: %u, LA Interfaces: %u, Inline interfaces: %u\n", |
| NofRings,NofLAInterfaces,NofInlineInterfaces); |
| |
| FLUE_Conf.InterfacesCount = NofRings + NofLAInterfaces + |
| NofInlineInterfaces; |
| if (FLUE_Conf.InterfacesCount == 0) |
| { |
| LOG_CRIT("GlobalControl207_Init: Device not initialized\n"); |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| } |
| |
| for (i = 0; i < FLUE_Conf.InterfacesCount; i++) |
| FLUE_Conf.InterfaceIndex[i] = 0; |
| |
| if (RPM_DEVICE_INIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| NULL, // Suspend callback not used |
| GlobalControl207Lib_Resume) != RPM_SUCCESS) |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| |
| if (GlobalControl207Lib_Init() != 0) |
| goto exit; // error |
| |
| // Configure the Record Cache functionality at the Ring Control |
| { |
| EIP207_Global_Capabilities_t Capabilities; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_HWRevision_Get \n"); |
| |
| rc = EIP207_Global_HWRevision_Get(&Global_IOArea, &Capabilities); |
| if (rc != EIP207_GLOBAL_NO_ERROR) |
| { |
| LOG_CRIT("GlobalControl207_Init: " |
| "EIP207_Global_HWRevision_Get() failed\n"); |
| goto exit; // error |
| } |
| |
| #ifndef GLOBALCONTROL_BUILD |
| #ifdef ADAPTER_CS_RC_SUPPORT |
| Adapter_RC_EIP207_Configure( |
| (ADAPTER_CS_TRC_ENABLED != 0), |
| (ADAPTER_CS_ARC4RC_ENABLED != 0) && |
| Capabilities.EIP207_Options.fARC4Present, |
| Capabilities.EIP207_Options.fCombinedTRC_ARC4); |
| #endif // ADAPTER_CS_RC_SUPPORT |
| #endif // GLOBALCONTROL_BUILD |
| } |
| |
| if (fLoadFirmware) |
| { |
| if (GlobalControl207Lib_Firmware_Load(true) != 0) |
| goto exit; |
| } |
| |
| { |
| EIP207_Firmware_Config_t FWConfig; |
| ZEROINIT(FWConfig); |
| #if defined(ADAPTER_CS_GLOBAL_IOTOKEN_METADATA_ENABLE) || \ |
| defined(ADAPTER_CS_GLOBAL_CFH_ENABLE) |
| FWConfig.fTokenExtensionsEnable = true; |
| #else |
| FWConfig.fTokenExtensionsEnable = false; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_INCREMENT_PKTID |
| FWConfig.fIncrementPktID = true; |
| #else |
| FWConfig.fIncrementPktID = false; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_ECN_CONTROL |
| FWConfig.ECNControl = ADAPTER_CS_GLOBAL_ECN_CONTROL; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_CCS |
| FWConfig.fDTLSDeferCCS = true; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_ALERT |
| FWConfig.fDTLSDeferAlert = true; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_HANDSHAKE |
| FWConfig.fDTLSDeferHandshake = true; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_APPDATA |
| FWConfig.fDTLSDeferAppData = true; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_CAPWAP |
| FWConfig.fDTLSDeferCAPWAP = true; |
| #endif |
| #ifdef ADAPTER_CS_GLOBAL_DTLS_HDR_ALIGN |
| FWConfig.DTLSRecordHeaderAlign = ADAPTER_CS_GLOBAL_DTLS_HDR_ALIGN; |
| #endif |
| FWConfig.TransformRedirEnable = ADAPTER_CS_GLOBAL_TRANSFORM_REDIRECT_ENABLE; |
| #ifdef ADAPTER_CS_GLOBAL_REDIR_RING |
| FWConfig.fRedirRingEnable = true; |
| FWConfig.RedirRing = ADAPTER_CS_GLOBAL_REDIR_RING; |
| #endif |
| // Configure the EIP-207 Firmware meta-data or CFH presence |
| // in the ICE scratch-path RAM |
| for (i = 0; i < NofCEs; i++) |
| { |
| EIP207_Global_Firmware_Configure(Device, i, &FWConfig); |
| if (FWConfig.fIncrementPktID) |
| { /* Give each engine its own range of PktID values */ |
| FWConfig.PktID += 4096; |
| } |
| } |
| } |
| Global_IsInitialized = true; |
| GC207_Rc = EIP207_GLOBAL_CONTROL_NO_ERROR; // success |
| |
| exit: |
| (void)RPM_DEVICE_INIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID); |
| |
| return GC207_Rc; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_UnInit |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_UnInit(void) |
| { |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| if (!Global_IsInitialized) |
| { |
| LOG_CRIT("GlobalControl207_UnInit: called while not initialized\n"); |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_USE_ORDER; |
| } |
| |
| (void)RPM_DEVICE_UNINIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, false); |
| (void)RPM_DEVICE_UNINIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID); |
| |
| Global_IsInitialized = false; |
| |
| return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_Status_Get |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_Status_Get( |
| const unsigned int CE_Number, |
| GlobalControl207_Status_t * const Status_p) |
| { |
| EIP207_Global_Error_t rc; |
| bool fFatalError; |
| |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_SYNC) != RPM_SUCCESS) |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_Status_Get \n"); |
| |
| rc = EIP207_Global_Status_Get(&Global_IOArea, |
| CE_Number, |
| Status_p, |
| &fFatalError); |
| |
| (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_ASYNC); |
| |
| if (rc == EIP207_GLOBAL_NO_ERROR) |
| { |
| if (fFatalError) |
| LOG_CRIT("GlobalControl207_Status_Get: Fatal Error detected, " |
| "reset required!\n"); |
| |
| return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| } |
| else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| else |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_GlobalStats_Get |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_GlobalStats_Get( |
| const unsigned int CE_Number, |
| GlobalControl207_GlobalStats_t * const GlobalStats_p) |
| { |
| EIP207_Global_Error_t rc; |
| |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_SYNC) != RPM_SUCCESS) |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_GlobalStats_Get \n"); |
| |
| rc = EIP207_Global_GlobalStats_Get(&Global_IOArea, |
| CE_Number, |
| GlobalStats_p); |
| |
| (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_ASYNC); |
| |
| if (rc == EIP207_GLOBAL_NO_ERROR) |
| return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| else |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| } |
| |
| |
| /*---------------------------------------------------------------------------- |
| * GlobalControl207_ClockCount_Get |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_ClockCount_Get( |
| const unsigned int CE_Number, |
| GlobalControl207_Clock_t * const Clock_p) |
| { |
| EIP207_Global_Error_t rc; |
| |
| LOG_INFO("\n\t\t\t %s \n", __func__); |
| |
| if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_SYNC) != RPM_SUCCESS) |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| |
| LOG_INFO("\n\t\t\t\t EIP207_Global_ClockCount_Get \n"); |
| |
| rc = EIP207_Global_ClockCount_Get(&Global_IOArea, |
| CE_Number, |
| Clock_p); |
| |
| (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| RPM_FLAG_ASYNC); |
| |
| if (rc == EIP207_GLOBAL_NO_ERROR) |
| return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| else |
| return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| } |
| |
| |
| /*--------------------- ------------------------------------------------------- |
| * GlobalControl207_Firmware_Configure |
| */ |
| GlobalControl207_Error_t |
| GlobalControl207_Firmware_Configure( |
| GlobalControl_Firmware_Config_t * const FWConfig_p) |
| { |
| unsigned i; |
| Device_Handle_t Device; |
| unsigned int NofCEs; |
| Device = Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME); |
| GlobalControl97_Interfaces_Get(&NofCEs, NULL, NULL, NULL); |
| if (FWConfig_p == NULL) |
| return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| FWConfig_p->PktID = 0; |
| // Configure the EIP-207 Firmware meta-data or CFH presence |
| // in the ICE scratch-path RAM |
| for (i = 0; i < NofCEs; i++) |
| { |
| EIP207_Global_Firmware_Configure(Device, i, FWConfig_p); |
| if (FWConfig_p->fIncrementPktID) |
| { /* Give each engine its own range of PktID values */ |
| FWConfig_p->PktID += 4096; |
| } |
| } |
| |
| return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| |
| } |
| |
| |
| /* end of file adapter_global_eip207.c */ |