developer | 02e6591 | 2023-08-17 16:33:10 +0800 | [diff] [blame^] | 1 | /* adapter_global_eip207.c |
| 2 | * |
| 3 | * Security-IP-207 Global Control Adapter |
| 4 | */ |
| 5 | |
| 6 | /***************************************************************************** |
| 7 | * Copyright (c) 2011-2022 by Rambus, Inc. and/or its subsidiaries. |
| 8 | * |
| 9 | * This program is free software: you can redistribute it and/or modify |
| 10 | * it under the terms of the GNU General Public License as published by |
| 11 | * the Free Software Foundation, either version 2 of the License, or |
| 12 | * any later version. |
| 13 | * |
| 14 | * This program is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 17 | * GNU General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU General Public License |
| 20 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 21 | *****************************************************************************/ |
| 22 | |
| 23 | /*---------------------------------------------------------------------------- |
| 24 | * This module implements (provides) the following interface(s): |
| 25 | */ |
| 26 | |
| 27 | // Classification (EIP-207) Global Control Initialization API |
| 28 | #include "api_global_eip207.h" |
| 29 | |
| 30 | // Classification (EIP-207) Global Control Status API |
| 31 | #include "api_global_status_eip207.h" |
| 32 | |
| 33 | |
| 34 | /*---------------------------------------------------------------------------- |
| 35 | * This module uses (requires) the following interface(s): |
| 36 | */ |
| 37 | #include "c_adapter_cs.h" |
| 38 | |
| 39 | #ifndef GLOBALCONTROL_BUILD |
| 40 | #include "adapter_rc_eip207.h" // Record Cache EIP-207 interface to pass |
| 41 | // config params from Global Control |
| 42 | #endif |
| 43 | |
| 44 | // Global Control API |
| 45 | #include "api_global_eip97.h" |
| 46 | |
| 47 | // Driver Framework Basic Definitions API |
| 48 | #include "basic_defs.h" // uint8_t, uint32_t, bool |
| 49 | |
| 50 | // Driver Framework C Library API |
| 51 | #include "clib.h" // memcpy, ZEROINIT |
| 52 | |
| 53 | // EIP-207 Driver Library Global Control API |
| 54 | #include "eip207_global_init.h" // Init/Uninit/Status/FW download |
| 55 | |
| 56 | // EIP-207 Driver Library Global Control API: Configuration |
| 57 | #include "eip207_global_config.h" // EIP207_Global_MetaData_Configure |
| 58 | |
| 59 | #include "device_types.h" // Device_Handle_t |
| 60 | #include "device_mgmt.h" // Device_find |
| 61 | |
| 62 | // Logging API |
| 63 | #include "log.h" // Log_*, LOG_* |
| 64 | |
| 65 | // Firmware load API. |
| 66 | #include "adapter_firmware.h" |
| 67 | #include "firmware_eip207_api_dwld.h" |
| 68 | |
| 69 | // Runtime Power Management Device Macros API |
| 70 | #include "rpm_device_macros.h" // RPM_* |
| 71 | |
| 72 | // EIP97_Supported_Funcs_Get() |
| 73 | #include "eip97_global_init.h" |
| 74 | |
| 75 | |
| 76 | /*---------------------------------------------------------------------------- |
| 77 | * Definitions and macros |
| 78 | */ |
| 79 | |
| 80 | /* Support legacy firmware packages without name parameters in download API */ |
| 81 | #ifndef FIRMWARE_EIP207_IPUE_NAME |
| 82 | #define FIRMWARE_EIP207_IPUE_NAME "firmware_eip207_ipue.bin" |
| 83 | #define FIRMWARE_EIP207_IFPP_NAME "firmware_eip207_ifpp.bin" |
| 84 | #endif |
| 85 | #ifndef FIRMWARE_EIP207_OPUE_NAME |
| 86 | #define FIRMWARE_EIP207_OPUE_NAME "firmware_eip207_opue.bin" |
| 87 | #define FIRMWARE_EIP207_OFPP_NAME "firmware_eip207_ofpp.bin" |
| 88 | #endif |
| 89 | |
| 90 | /*---------------------------------------------------------------------------- |
| 91 | * Local variables |
| 92 | */ |
| 93 | |
| 94 | static EIP207_Global_IOArea_t Global_IOArea; |
| 95 | static bool Global_IsInitialized; |
| 96 | |
| 97 | // Cached values during initialization will be used for RPM device resume |
| 98 | static EIP207_Global_CacheConfig_t RC_Conf; |
| 99 | static EIP207_Global_FLUEConfig_t FLUE_Conf; |
| 100 | |
| 101 | static const GlobalControl207_Capabilities_t Global_CapabilitiesString = |
| 102 | { |
| 103 | "EIP-207 v_._p_ #cache sets=__ #lookup tables=__" // szTextDescription |
| 104 | }; |
| 105 | |
| 106 | |
| 107 | /*---------------------------------------------------------------------------- |
| 108 | * YesNo |
| 109 | */ |
| 110 | static const char * |
| 111 | YesNo( |
| 112 | const bool b) |
| 113 | { |
| 114 | if (b) |
| 115 | return "Yes"; |
| 116 | else |
| 117 | return "No"; |
| 118 | } |
| 119 | |
| 120 | |
| 121 | /*---------------------------------------------------------------------------- |
| 122 | * GlobalControl207Lib_Init |
| 123 | * |
| 124 | */ |
| 125 | static int |
| 126 | GlobalControl207Lib_Init(void) |
| 127 | { |
| 128 | EIP207_Global_Error_t rc; |
| 129 | unsigned int i; |
| 130 | |
| 131 | LOG_INFO("\n\t\t\t\t EIP207_Global_Init \n"); |
| 132 | |
| 133 | rc = EIP207_Global_Init(&Global_IOArea, |
| 134 | Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME), |
| 135 | &RC_Conf, |
| 136 | &FLUE_Conf); |
| 137 | |
| 138 | for (i = 0; i < EIP207_GLOBAL_MAX_NOF_CACHE_SETS_TO_USE; i++) |
| 139 | { |
| 140 | Log_FormattedMessage("GlobalControl_EIP207_Init cache set %d:\n" |
| 141 | "\t\tFRC AdminWords=%5d DataWords=%5d\n" |
| 142 | "\t\tTRC AdminWords=%5d DataWords=%5d\n" |
| 143 | "\t\tARC4 AdminWords=%5d DataWords=%5d\n", |
| 144 | i, |
| 145 | RC_Conf.FRC[i].AdminWordCount, |
| 146 | RC_Conf.FRC[i].DataWordCount, |
| 147 | RC_Conf.TRC[i].AdminWordCount, |
| 148 | RC_Conf.TRC[i].DataWordCount, |
| 149 | RC_Conf.ARC4[i].AdminWordCount, |
| 150 | RC_Conf.ARC4[i].DataWordCount); |
| 151 | } |
| 152 | |
| 153 | if (rc != EIP207_GLOBAL_NO_ERROR) |
| 154 | { |
| 155 | LOG_CRIT("%s: EIP207_Global_Init() returned error %d\n", __func__, rc); |
| 156 | return -1; // error |
| 157 | } |
| 158 | |
| 159 | return 0; // success |
| 160 | } |
| 161 | |
| 162 | |
| 163 | /*---------------------------------------------------------------------------- |
| 164 | * GlobalControl207Lib_Firmware_Load |
| 165 | * |
| 166 | */ |
| 167 | static int |
| 168 | GlobalControl207Lib_Firmware_Load(bool fVerbose) |
| 169 | { |
| 170 | Adapter_Firmware_t IPUE_Handle, IFPP_Handle,OPUE_Handle, OFPP_Handle; |
| 171 | EIP207_Firmware_t IPUE_Firmware, IFPP_Firmware; |
| 172 | EIP207_Firmware_t OPUE_Firmware, OFPP_Firmware; |
| 173 | EIP207_Global_Error_t rc; |
| 174 | |
| 175 | ZEROINIT(IPUE_Firmware); |
| 176 | ZEROINIT(IFPP_Firmware); |
| 177 | ZEROINIT(OPUE_Firmware); |
| 178 | ZEROINIT(OFPP_Firmware); |
| 179 | |
| 180 | #ifdef FIRMWARE_EIP207_VERSION_MAJOR |
| 181 | // If version numbers are provided, then fill them in, so they |
| 182 | // will be checked against the actual firmware, else leave them |
| 183 | // at zero. |
| 184 | IPUE_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| 185 | IPUE_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| 186 | IPUE_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| 187 | IFPP_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| 188 | IFPP_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| 189 | IFPP_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| 190 | OPUE_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| 191 | OPUE_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| 192 | OPUE_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| 193 | OFPP_Firmware.Major = FIRMWARE_EIP207_VERSION_MAJOR; |
| 194 | OFPP_Firmware.Minor = FIRMWARE_EIP207_VERSION_MINOR; |
| 195 | OFPP_Firmware.PatchLevel = FIRMWARE_EIP207_VERSION_PATCH; |
| 196 | #endif |
| 197 | IPUE_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_IPUE_NAME, |
| 198 | &IPUE_Firmware.Image_p, |
| 199 | &IPUE_Firmware.ImageWordCount); |
| 200 | IFPP_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_IFPP_NAME, |
| 201 | &IFPP_Firmware.Image_p, |
| 202 | &IFPP_Firmware.ImageWordCount); |
| 203 | if ((EIP97_SupportedFuncs_Get() & BIT_1) != 0) |
| 204 | { |
| 205 | OPUE_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_OPUE_NAME, |
| 206 | &OPUE_Firmware.Image_p, |
| 207 | &OPUE_Firmware.ImageWordCount); |
| 208 | OFPP_Handle = Adapter_Firmware_Acquire(FIRMWARE_EIP207_OFPP_NAME, |
| 209 | &OFPP_Firmware.Image_p, |
| 210 | &OFPP_Firmware.ImageWordCount); |
| 211 | } |
| 212 | else |
| 213 | { |
| 214 | OPUE_Handle = Adapter_Firmware_NULL; |
| 215 | OFPP_Handle = Adapter_Firmware_NULL; |
| 216 | } |
| 217 | |
| 218 | LOG_INFO("\n\t\t\t\t EIP207_Global_Firmware_Load \n"); |
| 219 | |
| 220 | rc = EIP207_Global_Firmware_Load(&Global_IOArea, |
| 221 | ADAPTER_CS_TIMER_PRESCALER, |
| 222 | &IPUE_Firmware, |
| 223 | &IFPP_Firmware, |
| 224 | &OPUE_Firmware, |
| 225 | &OFPP_Firmware); |
| 226 | Adapter_Firmware_Release(IPUE_Handle); |
| 227 | Adapter_Firmware_Release(IFPP_Handle); |
| 228 | Adapter_Firmware_Release(OPUE_Handle); |
| 229 | Adapter_Firmware_Release(OFPP_Handle); |
| 230 | if (rc != EIP207_GLOBAL_NO_ERROR) |
| 231 | { |
| 232 | LOG_CRIT("GlobalControl207_Init: " |
| 233 | "EIP207_Global_Firmware_Load() failed\n"); |
| 234 | return -3; // error |
| 235 | } |
| 236 | else if (fVerbose) |
| 237 | { |
| 238 | LOG_CRIT("GlobalControl207_Init: firmware " |
| 239 | "downloaded successfully\n"); |
| 240 | |
| 241 | LOG_CRIT("\tIPUE firmware v%d.%d.%d, image byte count %d\n", |
| 242 | IPUE_Firmware.Major, |
| 243 | IPUE_Firmware.Minor, |
| 244 | IPUE_Firmware.PatchLevel, |
| 245 | (int)(IPUE_Firmware.ImageWordCount * sizeof(uint32_t))); |
| 246 | |
| 247 | LOG_CRIT("\tIFPP firmware v%d.%d.%d, image byte count %d\n\n", |
| 248 | IFPP_Firmware.Major, |
| 249 | IFPP_Firmware.Minor, |
| 250 | IFPP_Firmware.PatchLevel, |
| 251 | (int)(IFPP_Firmware.ImageWordCount * sizeof(uint32_t))); |
| 252 | |
| 253 | LOG_CRIT("\tOPUE firmware v%d.%d.%d, image byte count %d\n", |
| 254 | OPUE_Firmware.Major, |
| 255 | OPUE_Firmware.Minor, |
| 256 | OPUE_Firmware.PatchLevel, |
| 257 | (int)(OPUE_Firmware.ImageWordCount * sizeof(uint32_t))); |
| 258 | |
| 259 | LOG_CRIT("\tOFPP firmware v%d.%d.%d, image byte count %d\n\n", |
| 260 | OFPP_Firmware.Major, |
| 261 | OFPP_Firmware.Minor, |
| 262 | OFPP_Firmware.PatchLevel, |
| 263 | (int)(OFPP_Firmware.ImageWordCount * sizeof(uint32_t))); |
| 264 | } |
| 265 | return 0; |
| 266 | } |
| 267 | |
| 268 | #ifdef ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID |
| 269 | /*---------------------------------------------------------------------------- |
| 270 | * GlobalControl207Lib_Resume |
| 271 | * |
| 272 | */ |
| 273 | static int |
| 274 | GlobalControl207Lib_Resume(void * p) |
| 275 | { |
| 276 | EIP207_Global_Error_t rc; |
| 277 | EIP207_Firmware_t IPUE_Firmware, IFPP_Firmware; |
| 278 | EIP207_Firmware_t OPUE_Firmware, OFPP_Firmware; |
| 279 | |
| 280 | IDENTIFIER_NOT_USED(p); |
| 281 | |
| 282 | if (GlobalControl207Lib_Init() != 0) |
| 283 | return -1; // error |
| 284 | |
| 285 | if (GlobalControl207Lib_Firmware_Load(false) != 0) |
| 286 | return -2; // error |
| 287 | |
| 288 | return 0; // success |
| 289 | } |
| 290 | #endif |
| 291 | |
| 292 | |
| 293 | /*---------------------------------------------------------------------------- |
| 294 | * GlobalControl207_Capabilities_Get |
| 295 | */ |
| 296 | void |
| 297 | GlobalControl207_Capabilities_Get( |
| 298 | GlobalControl207_Capabilities_t * const Capabilities_p) |
| 299 | { |
| 300 | uint8_t Versions[7]; |
| 301 | |
| 302 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 303 | |
| 304 | memcpy(Capabilities_p, &Global_CapabilitiesString, |
| 305 | sizeof(Global_CapabilitiesString)); |
| 306 | |
| 307 | { |
| 308 | EIP207_Global_Error_t rc; |
| 309 | EIP207_Global_Capabilities_t Capabilities; |
| 310 | |
| 311 | if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 312 | RPM_FLAG_SYNC) != RPM_SUCCESS) |
| 313 | return; |
| 314 | |
| 315 | LOG_INFO("\n\t\t\t\t EIP207_Global_HWRevision_Get \n"); |
| 316 | |
| 317 | rc = EIP207_Global_HWRevision_Get(&Global_IOArea, &Capabilities); |
| 318 | |
| 319 | (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 320 | RPM_FLAG_ASYNC); |
| 321 | |
| 322 | if (rc != EIP207_GLOBAL_NO_ERROR) |
| 323 | { |
| 324 | LOG_CRIT("GlobalControl207_Capabilities_Get: " |
| 325 | "EIP207_Global_HWRevision_Get() failed\n"); |
| 326 | return; |
| 327 | } |
| 328 | |
| 329 | // Show those capabilities not propagated to higher layer. |
| 330 | LOG_CRIT("EIP-207 capabilities\n"); |
| 331 | LOG_CRIT("\tLookup cached: %s\n" |
| 332 | "\tFRC combined with TRC: %s\n" |
| 333 | "\tARC4RC present: %s\n" |
| 334 | "\tFRC combined with ARC4RC: %s\n" |
| 335 | "\tTRC combined with ARC4RC: %s\n" |
| 336 | "\tFRC clients: %d\n" |
| 337 | "\tTRC clients: %d\n" |
| 338 | "\tARC4RC clients: %d\n" |
| 339 | "\tLookup clients: %d\n\n", |
| 340 | YesNo(Capabilities.EIP207_Options.fLookupCached), |
| 341 | YesNo(Capabilities.EIP207_Options.fCombinedFRC_TRC), |
| 342 | YesNo(Capabilities.EIP207_Options.fARC4Present), |
| 343 | YesNo(Capabilities.EIP207_Options.fCombinedFRC_ARC4), |
| 344 | YesNo(Capabilities.EIP207_Options.fCombinedTRC_ARC4), |
| 345 | Capabilities.EIP207_Options.NofFRC_Clients, |
| 346 | Capabilities.EIP207_Options.NofTRC_Clients, |
| 347 | Capabilities.EIP207_Options.NofARC4_Clients, |
| 348 | Capabilities.EIP207_Options.NofLookupClients); |
| 349 | |
| 350 | Versions[0] = Capabilities.EIP207_Version.MajHWRevision; |
| 351 | Versions[1] = Capabilities.EIP207_Version.MinHWRevision; |
| 352 | Versions[2] = Capabilities.EIP207_Version.HWPatchLevel; |
| 353 | |
| 354 | Versions[3] = Capabilities.EIP207_Options.NofCacheSets / 10; |
| 355 | Versions[4] = Capabilities.EIP207_Options.NofCacheSets % 10; |
| 356 | |
| 357 | Versions[5] = Capabilities.EIP207_Options.NofLookupTables / 10; |
| 358 | Versions[6] = Capabilities.EIP207_Options.NofLookupTables % 10; |
| 359 | } |
| 360 | |
| 361 | { |
| 362 | char * p = Capabilities_p->szTextDescription; |
| 363 | int VerIndex = 0; |
| 364 | int i = 0; |
| 365 | |
| 366 | while(p[i]) |
| 367 | { |
| 368 | if (p[i] == '_') |
| 369 | { |
| 370 | if (Versions[VerIndex] > 9) |
| 371 | p[i] = '?'; |
| 372 | else |
| 373 | p[i] = '0' + Versions[VerIndex++]; |
| 374 | |
| 375 | if (VerIndex >= 7) |
| 376 | break; |
| 377 | } |
| 378 | |
| 379 | i++; |
| 380 | } |
| 381 | } |
| 382 | |
| 383 | return; |
| 384 | } |
| 385 | |
| 386 | /*---------------------------------------------------------------------------- |
| 387 | * GlobalControl207_Init |
| 388 | */ |
| 389 | GlobalControl207_Error_t |
| 390 | GlobalControl207_Init( |
| 391 | const bool fLoadFirmware, |
| 392 | const GlobalControl207_IV_t * const IV_p) |
| 393 | { |
| 394 | unsigned int i; |
| 395 | GlobalControl207_Error_t GC207_Rc = EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 396 | EIP207_Global_Error_t rc; |
| 397 | Device_Handle_t Device; |
| 398 | unsigned int NofCEs,NofRings,NofLAInterfaces,NofInlineInterfaces; |
| 399 | |
| 400 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 401 | |
| 402 | if (Global_IsInitialized) |
| 403 | { |
| 404 | LOG_CRIT("GlobalControl207_Init: called while already initialized\n"); |
| 405 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_USE_ORDER; |
| 406 | } |
| 407 | |
| 408 | Device = Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME); |
| 409 | if (Device == NULL) |
| 410 | { |
| 411 | LOG_CRIT("GlobalControl207_Init: Could not find device\n"); |
| 412 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 413 | } |
| 414 | |
| 415 | ZEROINIT(RC_Conf); |
| 416 | ZEROINIT(FLUE_Conf); |
| 417 | |
| 418 | // Record Caches initialization parameters |
| 419 | for (i = 0; i < EIP207_GLOBAL_MAX_NOF_CACHE_SETS_TO_USE; i++) |
| 420 | { |
| 421 | RC_Conf.FRC[i].fEnable = (ADAPTER_CS_FRC_ENABLED != 0); |
| 422 | RC_Conf.FRC[i].fNonBlock = false; |
| 423 | RC_Conf.FRC[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| 424 | RC_Conf.FRC[i].RecBaseAddr.Value64_Lo = 0; |
| 425 | RC_Conf.FRC[i].RecBaseAddr.Value64_Hi = 0; |
| 426 | |
| 427 | RC_Conf.TRC[i].fEnable = (ADAPTER_CS_TRC_ENABLED != 0); |
| 428 | RC_Conf.TRC[i].fNonBlock = false; |
| 429 | RC_Conf.TRC[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| 430 | RC_Conf.TRC[i].RecBaseAddr.Value64_Lo = 0; |
| 431 | RC_Conf.TRC[i].RecBaseAddr.Value64_Hi = 0; |
| 432 | |
| 433 | RC_Conf.ARC4[i].fEnable = (ADAPTER_CS_ARC4RC_ENABLED != 0); |
| 434 | RC_Conf.ARC4[i].fNonBlock = false; |
| 435 | RC_Conf.ARC4[i].BlockClockCount = ADAPTER_CS_RC_BLOCK_CLOCK_COUNT; |
| 436 | RC_Conf.ARC4[i].RecBaseAddr.Value64_Lo = 0; |
| 437 | RC_Conf.ARC4[i].RecBaseAddr.Value64_Hi = 0; |
| 438 | } |
| 439 | |
| 440 | // Flow Look-Up Engine initialization parameters |
| 441 | FLUE_Conf.CacheChain = ADAPTER_CS_FLUE_CACHE_CHAIN; |
| 442 | FLUE_Conf.fDelayMemXS = (ADAPTER_CS_FLUE_MEMXS_DELAY != 0); |
| 443 | FLUE_Conf.IV.IV_Word32[0] = IV_p->IV[0]; |
| 444 | FLUE_Conf.IV.IV_Word32[1] = IV_p->IV[1]; |
| 445 | FLUE_Conf.IV.IV_Word32[2] = IV_p->IV[2]; |
| 446 | FLUE_Conf.IV.IV_Word32[3] = IV_p->IV[3]; |
| 447 | |
| 448 | // Hash table initialization parameters |
| 449 | FLUE_Conf.HashTablesCount = ADAPTER_CS_MAX_NOF_FLOW_HASH_TABLES_TO_USE; |
| 450 | for (i = 0; i < FLUE_Conf.HashTablesCount; i++) |
| 451 | { |
| 452 | FLUE_Conf.HashTable[i].fLookupCached = |
| 453 | (ADAPTER_CS_FLUE_LOOKUP_CACHED != 0); |
| 454 | FLUE_Conf.HashTable[i].fPrefetchXform = |
| 455 | (ADAPTER_CS_FLUE_PREFETCH_XFORM != 0); |
| 456 | FLUE_Conf.HashTable[i].fPrefetchARC4State = |
| 457 | (ADAPTER_CS_FLUE_PREFETCH_ARC4 != 0); |
| 458 | } |
| 459 | |
| 460 | GlobalControl97_Interfaces_Get(&NofCEs, &NofRings, &NofLAInterfaces, &NofInlineInterfaces); |
| 461 | LOG_CRIT("GlobalControl_EIP207_Init:\n" |
| 462 | "Number of Rings: %u, LA Interfaces: %u, Inline interfaces: %u\n", |
| 463 | NofRings,NofLAInterfaces,NofInlineInterfaces); |
| 464 | |
| 465 | FLUE_Conf.InterfacesCount = NofRings + NofLAInterfaces + |
| 466 | NofInlineInterfaces; |
| 467 | if (FLUE_Conf.InterfacesCount == 0) |
| 468 | { |
| 469 | LOG_CRIT("GlobalControl207_Init: Device not initialized\n"); |
| 470 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 471 | } |
| 472 | |
| 473 | for (i = 0; i < FLUE_Conf.InterfacesCount; i++) |
| 474 | FLUE_Conf.InterfaceIndex[i] = 0; |
| 475 | |
| 476 | if (RPM_DEVICE_INIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 477 | NULL, // Suspend callback not used |
| 478 | GlobalControl207Lib_Resume) != RPM_SUCCESS) |
| 479 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 480 | |
| 481 | if (GlobalControl207Lib_Init() != 0) |
| 482 | goto exit; // error |
| 483 | |
| 484 | // Configure the Record Cache functionality at the Ring Control |
| 485 | { |
| 486 | EIP207_Global_Capabilities_t Capabilities; |
| 487 | |
| 488 | LOG_INFO("\n\t\t\t\t EIP207_Global_HWRevision_Get \n"); |
| 489 | |
| 490 | rc = EIP207_Global_HWRevision_Get(&Global_IOArea, &Capabilities); |
| 491 | if (rc != EIP207_GLOBAL_NO_ERROR) |
| 492 | { |
| 493 | LOG_CRIT("GlobalControl207_Init: " |
| 494 | "EIP207_Global_HWRevision_Get() failed\n"); |
| 495 | goto exit; // error |
| 496 | } |
| 497 | |
| 498 | #ifndef GLOBALCONTROL_BUILD |
| 499 | #ifdef ADAPTER_CS_RC_SUPPORT |
| 500 | Adapter_RC_EIP207_Configure( |
| 501 | (ADAPTER_CS_TRC_ENABLED != 0), |
| 502 | (ADAPTER_CS_ARC4RC_ENABLED != 0) && |
| 503 | Capabilities.EIP207_Options.fARC4Present, |
| 504 | Capabilities.EIP207_Options.fCombinedTRC_ARC4); |
| 505 | #endif // ADAPTER_CS_RC_SUPPORT |
| 506 | #endif // GLOBALCONTROL_BUILD |
| 507 | } |
| 508 | |
| 509 | if (fLoadFirmware) |
| 510 | { |
| 511 | if (GlobalControl207Lib_Firmware_Load(true) != 0) |
| 512 | goto exit; |
| 513 | } |
| 514 | |
| 515 | { |
| 516 | EIP207_Firmware_Config_t FWConfig; |
| 517 | ZEROINIT(FWConfig); |
| 518 | #if defined(ADAPTER_CS_GLOBAL_IOTOKEN_METADATA_ENABLE) || \ |
| 519 | defined(ADAPTER_CS_GLOBAL_CFH_ENABLE) |
| 520 | FWConfig.fTokenExtensionsEnable = true; |
| 521 | #else |
| 522 | FWConfig.fTokenExtensionsEnable = false; |
| 523 | #endif |
| 524 | #ifdef ADAPTER_CS_GLOBAL_INCREMENT_PKTID |
| 525 | FWConfig.fIncrementPktID = true; |
| 526 | #else |
| 527 | FWConfig.fIncrementPktID = false; |
| 528 | #endif |
| 529 | #ifdef ADAPTER_CS_GLOBAL_ECN_CONTROL |
| 530 | FWConfig.ECNControl = ADAPTER_CS_GLOBAL_ECN_CONTROL; |
| 531 | #endif |
| 532 | #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_CCS |
| 533 | FWConfig.fDTLSDeferCCS = true; |
| 534 | #endif |
| 535 | #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_ALERT |
| 536 | FWConfig.fDTLSDeferAlert = true; |
| 537 | #endif |
| 538 | #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_HANDSHAKE |
| 539 | FWConfig.fDTLSDeferHandshake = true; |
| 540 | #endif |
| 541 | #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_APPDATA |
| 542 | FWConfig.fDTLSDeferAppData = true; |
| 543 | #endif |
| 544 | #ifdef ADAPTER_CS_GLOBAL_DTLS_DEFER_CAPWAP |
| 545 | FWConfig.fDTLSDeferCAPWAP = true; |
| 546 | #endif |
| 547 | #ifdef ADAPTER_CS_GLOBAL_DTLS_HDR_ALIGN |
| 548 | FWConfig.DTLSRecordHeaderAlign = ADAPTER_CS_GLOBAL_DTLS_HDR_ALIGN; |
| 549 | #endif |
| 550 | FWConfig.TransformRedirEnable = ADAPTER_CS_GLOBAL_TRANSFORM_REDIRECT_ENABLE; |
| 551 | #ifdef ADAPTER_CS_GLOBAL_REDIR_RING |
| 552 | FWConfig.fRedirRingEnable = true; |
| 553 | FWConfig.RedirRing = ADAPTER_CS_GLOBAL_REDIR_RING; |
| 554 | #endif |
| 555 | // Configure the EIP-207 Firmware meta-data or CFH presence |
| 556 | // in the ICE scratch-path RAM |
| 557 | for (i = 0; i < NofCEs; i++) |
| 558 | { |
| 559 | EIP207_Global_Firmware_Configure(Device, i, &FWConfig); |
| 560 | if (FWConfig.fIncrementPktID) |
| 561 | { /* Give each engine its own range of PktID values */ |
| 562 | FWConfig.PktID += 4096; |
| 563 | } |
| 564 | } |
| 565 | } |
| 566 | Global_IsInitialized = true; |
| 567 | GC207_Rc = EIP207_GLOBAL_CONTROL_NO_ERROR; // success |
| 568 | |
| 569 | exit: |
| 570 | (void)RPM_DEVICE_INIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID); |
| 571 | |
| 572 | return GC207_Rc; |
| 573 | } |
| 574 | |
| 575 | |
| 576 | /*---------------------------------------------------------------------------- |
| 577 | * GlobalControl207_UnInit |
| 578 | */ |
| 579 | GlobalControl207_Error_t |
| 580 | GlobalControl207_UnInit(void) |
| 581 | { |
| 582 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 583 | |
| 584 | if (!Global_IsInitialized) |
| 585 | { |
| 586 | LOG_CRIT("GlobalControl207_UnInit: called while not initialized\n"); |
| 587 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_USE_ORDER; |
| 588 | } |
| 589 | |
| 590 | (void)RPM_DEVICE_UNINIT_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, false); |
| 591 | (void)RPM_DEVICE_UNINIT_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID); |
| 592 | |
| 593 | Global_IsInitialized = false; |
| 594 | |
| 595 | return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| 596 | } |
| 597 | |
| 598 | |
| 599 | /*---------------------------------------------------------------------------- |
| 600 | * GlobalControl207_Status_Get |
| 601 | */ |
| 602 | GlobalControl207_Error_t |
| 603 | GlobalControl207_Status_Get( |
| 604 | const unsigned int CE_Number, |
| 605 | GlobalControl207_Status_t * const Status_p) |
| 606 | { |
| 607 | EIP207_Global_Error_t rc; |
| 608 | bool fFatalError; |
| 609 | |
| 610 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 611 | |
| 612 | if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 613 | RPM_FLAG_SYNC) != RPM_SUCCESS) |
| 614 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 615 | |
| 616 | LOG_INFO("\n\t\t\t\t EIP207_Global_Status_Get \n"); |
| 617 | |
| 618 | rc = EIP207_Global_Status_Get(&Global_IOArea, |
| 619 | CE_Number, |
| 620 | Status_p, |
| 621 | &fFatalError); |
| 622 | |
| 623 | (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 624 | RPM_FLAG_ASYNC); |
| 625 | |
| 626 | if (rc == EIP207_GLOBAL_NO_ERROR) |
| 627 | { |
| 628 | if (fFatalError) |
| 629 | LOG_CRIT("GlobalControl207_Status_Get: Fatal Error detected, " |
| 630 | "reset required!\n"); |
| 631 | |
| 632 | return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| 633 | } |
| 634 | else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| 635 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| 636 | else |
| 637 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 638 | } |
| 639 | |
| 640 | |
| 641 | /*---------------------------------------------------------------------------- |
| 642 | * GlobalControl207_GlobalStats_Get |
| 643 | */ |
| 644 | GlobalControl207_Error_t |
| 645 | GlobalControl207_GlobalStats_Get( |
| 646 | const unsigned int CE_Number, |
| 647 | GlobalControl207_GlobalStats_t * const GlobalStats_p) |
| 648 | { |
| 649 | EIP207_Global_Error_t rc; |
| 650 | |
| 651 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 652 | |
| 653 | if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 654 | RPM_FLAG_SYNC) != RPM_SUCCESS) |
| 655 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 656 | |
| 657 | LOG_INFO("\n\t\t\t\t EIP207_Global_GlobalStats_Get \n"); |
| 658 | |
| 659 | rc = EIP207_Global_GlobalStats_Get(&Global_IOArea, |
| 660 | CE_Number, |
| 661 | GlobalStats_p); |
| 662 | |
| 663 | (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 664 | RPM_FLAG_ASYNC); |
| 665 | |
| 666 | if (rc == EIP207_GLOBAL_NO_ERROR) |
| 667 | return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| 668 | else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| 669 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| 670 | else |
| 671 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 672 | } |
| 673 | |
| 674 | |
| 675 | /*---------------------------------------------------------------------------- |
| 676 | * GlobalControl207_ClockCount_Get |
| 677 | */ |
| 678 | GlobalControl207_Error_t |
| 679 | GlobalControl207_ClockCount_Get( |
| 680 | const unsigned int CE_Number, |
| 681 | GlobalControl207_Clock_t * const Clock_p) |
| 682 | { |
| 683 | EIP207_Global_Error_t rc; |
| 684 | |
| 685 | LOG_INFO("\n\t\t\t %s \n", __func__); |
| 686 | |
| 687 | if (RPM_DEVICE_IO_START_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 688 | RPM_FLAG_SYNC) != RPM_SUCCESS) |
| 689 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 690 | |
| 691 | LOG_INFO("\n\t\t\t\t EIP207_Global_ClockCount_Get \n"); |
| 692 | |
| 693 | rc = EIP207_Global_ClockCount_Get(&Global_IOArea, |
| 694 | CE_Number, |
| 695 | Clock_p); |
| 696 | |
| 697 | (void)RPM_DEVICE_IO_STOP_MACRO(ADAPTER_GLOBAL_RPM_EIP207_DEVICE_ID, |
| 698 | RPM_FLAG_ASYNC); |
| 699 | |
| 700 | if (rc == EIP207_GLOBAL_NO_ERROR) |
| 701 | return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| 702 | else if (rc == EIP207_GLOBAL_ARGUMENT_ERROR) |
| 703 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| 704 | else |
| 705 | return EIP207_GLOBAL_CONTROL_ERROR_INTERNAL; |
| 706 | } |
| 707 | |
| 708 | |
| 709 | /*--------------------- ------------------------------------------------------- |
| 710 | * GlobalControl207_Firmware_Configure |
| 711 | */ |
| 712 | GlobalControl207_Error_t |
| 713 | GlobalControl207_Firmware_Configure( |
| 714 | GlobalControl_Firmware_Config_t * const FWConfig_p) |
| 715 | { |
| 716 | unsigned i; |
| 717 | Device_Handle_t Device; |
| 718 | unsigned int NofCEs; |
| 719 | Device = Device_Find(ADAPTER_CS_GLOBAL_DEVICE_NAME); |
| 720 | GlobalControl97_Interfaces_Get(&NofCEs, NULL, NULL, NULL); |
| 721 | if (FWConfig_p == NULL) |
| 722 | return EIP207_GLOBAL_CONTROL_ERROR_BAD_PARAMETER; |
| 723 | FWConfig_p->PktID = 0; |
| 724 | // Configure the EIP-207 Firmware meta-data or CFH presence |
| 725 | // in the ICE scratch-path RAM |
| 726 | for (i = 0; i < NofCEs; i++) |
| 727 | { |
| 728 | EIP207_Global_Firmware_Configure(Device, i, FWConfig_p); |
| 729 | if (FWConfig_p->fIncrementPktID) |
| 730 | { /* Give each engine its own range of PktID values */ |
| 731 | FWConfig_p->PktID += 4096; |
| 732 | } |
| 733 | } |
| 734 | |
| 735 | return EIP207_GLOBAL_CONTROL_NO_ERROR; |
| 736 | |
| 737 | } |
| 738 | |
| 739 | |
| 740 | /* end of file adapter_global_eip207.c */ |