sys/dev/pci/n8/common/api/n8_pub_enums.c

   1 /*****************************************************************************
   2  * %A%
   3  *****************************************************************************/
   4
   5 /*****************************************************************************/
   6 /** @file common/api/n8_pub_enums.c
   7  *  @brief Generated file for converting enum values to text.
   8  *
   9  * This file generated by genEnumText.py.  Do not edit by hand.
  10  *
  11  *****************************************************************************/
  12
  13 /*****************************************************************************
  14  * Revision history:
  15  * 03/02/04 ---   Generated.
  16  ****************************************************************************/
  17
  18 #include "n8_pub_enums.h"
  19
  20 /*****************************************************************************/
  21 const char * N8_Hardware_t_text(const N8_Hardware_t enumValue)
  22 {
  23    const char *ret;
  24    switch (enumValue)
  25    {
  26       case N8_NSP2000_HW:
  27          ret = "N8_NSP2000_HW";
  28          break;
  29       case N8_BM:
  30          ret = "N8_BM";
  31          break;
  32       case N8_FPGA:
  33          ret = "N8_FPGA";
  34          break;
  35       default:
  36          ret = "Invalid enumeration value for N8_Hardware_t";
  37    }
  38
  39    return ret;
  40 }   /* N8_Hardware_t_text */
  41
  42 /*****************************************************************************/
  43 const char * N8_QueueStatusCodes_t_text(const N8_QueueStatusCodes_t enumValue)
  44 {
  45    const char *ret;
  46    switch (enumValue)
  47    {
  48       case N8_QUEUE_REQUEST_SENT_FROM_API:
  49          ret = "N8_QUEUE_REQUEST_SENT_FROM_API";
  50          break;
  51       case N8_QUEUE_REQUEST_QUEUED:
  52          ret = "N8_QUEUE_REQUEST_QUEUED";
  53          break;
  54       case N8_QUEUE_REQUEST_FINISHED:
  55          ret = "N8_QUEUE_REQUEST_FINISHED";
  56          break;
  57       case N8_QUEUE_REQUEST_COMMAND_ERROR:
  58          ret = "N8_QUEUE_REQUEST_COMMAND_ERROR";
  59          break;
  60       default:
  61          ret = "Invalid enumeration value for N8_QueueStatusCodes_t";
  62    }
  63
  64    return ret;
  65 }   /* N8_QueueStatusCodes_t_text */
  66
  67 /*****************************************************************************/
  68 const char * N8_Status_t_text(const N8_Status_t enumValue)
  69 {
  70    const char *ret;
  71    switch (enumValue)
  72    {
  73       case N8_STATUS_OK:
  74          ret = "N8_STATUS_OK";
  75          break;
  76       case N8_EVENT_COMPLETE:
  77          ret = "N8_EVENT_COMPLETE";
  78          break;
  79       case N8_EVENT_INCOMPLETE:
  80          ret = "N8_EVENT_INCOMPLETE";
  81          break;
  82       case N8_INVALID_INPUT_SIZE:
  83          ret = "N8_INVALID_INPUT_SIZE";
  84          break;
  85       case N8_INVALID_OUTPUT_SIZE:
  86          ret = "N8_INVALID_OUTPUT_SIZE";
  87          break;
  88       case N8_INVALID_ENUM:
  89          ret = "N8_INVALID_ENUM";
  90          break;
  91       case N8_INVALID_PARAMETER:
  92          ret = "N8_INVALID_PARAMETER";
  93          break;
  94       case N8_INVALID_OBJECT:
  95          ret = "N8_INVALID_OBJECT";
  96          break;
  97       case N8_INVALID_KEY:
  98          ret = "N8_INVALID_KEY";
  99          break;
 100       case N8_INVALID_KEY_SIZE:
 101          ret = "N8_INVALID_KEY_SIZE";
 102          break;
 103       case N8_INVALID_PROTOCOL:
 104          ret = "N8_INVALID_PROTOCOL";
 105          break;
 106       case N8_INVALID_CIPHER:
 107          ret = "N8_INVALID_CIPHER";
 108          break;
 109       case N8_INVALID_HASH:
 110          ret = "N8_INVALID_HASH";
 111          break;
 112       case N8_INVALID_VALUE:
 113          ret = "N8_INVALID_VALUE";
 114          break;
 115       case N8_INVALID_VERSION:
 116          ret = "N8_INVALID_VERSION";
 117          break;
 118       case N8_INCONSISTENT:
 119          ret = "N8_INCONSISTENT";
 120          break;
 121       case N8_NOT_INITIALIZED:
 122          ret = "N8_NOT_INITIALIZED";
 123          break;
 124       case N8_UNALLOCATED_CONTEXT:
 125          ret = "N8_UNALLOCATED_CONTEXT";
 126          break;
 127       case N8_NO_MORE_RESOURCE:
 128          ret = "N8_NO_MORE_RESOURCE";
 129          break;
 130       case N8_HARDWARE_ERROR:
 131          ret = "N8_HARDWARE_ERROR";
 132          break;
 133       case N8_UNEXPECTED_ERROR:
 134          ret = "N8_UNEXPECTED_ERROR";
 135          break;
 136       case N8_UNIMPLEMENTED_FUNCTION:
 137          ret = "N8_UNIMPLEMENTED_FUNCTION";
 138          break;
 139       case N8_MALLOC_FAILED:
 140          ret = "N8_MALLOC_FAILED";
 141          break;
 142       case N8_WEAK_KEY:
 143          ret = "N8_WEAK_KEY";
 144          break;
 145       case N8_VERIFICATION_FAILED:
 146          ret = "N8_VERIFICATION_FAILED";
 147          break;
 148       case N8_ALREADY_INITIALIZED:
 149          ret = "N8_ALREADY_INITIALIZED";
 150          break;
 151       case N8_FILE_ERROR:
 152          ret = "N8_FILE_ERROR";
 153          break;
 154       case N8_STATUS_ATTACH_OK:
 155          ret = "N8_STATUS_ATTACH_OK";
 156          break;
 157       case N8_QUEUE_ERROR:
 158          ret = "N8_QUEUE_ERROR";
 159          break;
 160       case N8_INVALID_UNIT:
 161          ret = "N8_INVALID_UNIT";
 162          break;
 163       case N8_UNALIGNED_ADDRESS:
 164          ret = "N8_UNALIGNED_ADDRESS";
 165          break;
 166       case N8_QUEUE_FULL:
 167          ret = "N8_QUEUE_FULL";
 168          break;
 169       case N8_INVALID_DRIVER_VERSION:
 170          ret = "N8_INVALID_DRIVER_VERSION";
 171          break;
 172       case N8_HARDWARE_UNAVAILABLE:
 173          ret = "N8_HARDWARE_UNAVAILABLE";
 174          break;
 175       case N8_API_QUEUE_FULL:
 176          ret = "N8_API_QUEUE_FULL";
 177          break;
 178       case N8_RNG_QUEUE_EMPTY:
 179          ret = "N8_RNG_QUEUE_EMPTY";
 180          break;
 181       case N8_TIMEOUT:
 182          ret = "N8_TIMEOUT";
 183          break;
 184       case N8_INCOMPATIBLE_OPEN:
 185          ret = "N8_INCOMPATIBLE_OPEN";
 186          break;
 187       case N8_EVENT_ALLOC_FAILED:
 188          ret = "N8_EVENT_ALLOC_FAILED";
 189          break;
 190       case N8_THREAD_INIT_FAILED:
 191          ret = "N8_THREAD_INIT_FAILED";
 192          break;
 193       case N8_EVENT_QUEUE_FULL:
 194          ret = "N8_EVENT_QUEUE_FULL";
 195          break;
 196       default:
 197          ret = "Invalid enumeration value for N8_Status_t";
 198    }
 199
 200    return ret;
 201 }   /* N8_Status_t_text */
 202
 203 /*****************************************************************************/
 204 const char * N8_HashProtocol_t_text(const N8_HashProtocol_t enumValue)
 205 {
 206    const char *ret;
 207    switch (enumValue)
 208    {
 209       case N8_TLS_FINISH:
 210          ret = "N8_TLS_FINISH";
 211          break;
 212       case N8_TLS_CERT:
 213          ret = "N8_TLS_CERT";
 214          break;
 215       case N8_SSL_FINISH:
 216          ret = "N8_SSL_FINISH";
 217          break;
 218       case N8_SSL_CERT:
 219          ret = "N8_SSL_CERT";
 220          break;
 221       default:
 222          ret = "Invalid enumeration value for N8_HashProtocol_t";
 223    }
 224
 225    return ret;
 226 }   /* N8_HashProtocol_t_text */
 227
 228 /*****************************************************************************/
 229 const char * N8_SKSKeyType_t_text(const N8_SKSKeyType_t enumValue)
 230 {
 231    const char *ret;
 232    switch (enumValue)
 233    {
 234       case N8_RSA_VERSION_1_KEY:
 235          ret = "N8_RSA_VERSION_1_KEY";
 236          break;
 237       case N8_DSA_VERSION_1_KEY:
 238          ret = "N8_DSA_VERSION_1_KEY";
 239          break;
 240       default:
 241          ret = "Invalid enumeration value for N8_SKSKeyType_t";
 242    }
 243
 244    return ret;
 245 }   /* N8_SKSKeyType_t_text */
 246
 247 /*****************************************************************************/
 248 const char * N8_Cipher_t_text(const N8_Cipher_t enumValue)
 249 {
 250    const char *ret;
 251    switch (enumValue)
 252    {
 253       case N8_CIPHER_ARC4:
 254          ret = "N8_CIPHER_ARC4";
 255          break;
 256       case N8_CIPHER_DES:
 257          ret = "N8_CIPHER_DES";
 258          break;
 259       default:
 260          ret = "Invalid enumeration value for N8_Cipher_t";
 261    }
 262
 263    return ret;
 264 }   /* N8_Cipher_t_text */
 265
 266 /*****************************************************************************/
 267 const char * N8_Component_t_text(const N8_Component_t enumValue)
 268 {
 269    const char *ret;
 270    switch (enumValue)
 271    {
 272       case N8_PKP:
 273          ret = "N8_PKP";
 274          break;
 275       case N8_RNG:
 276          ret = "N8_RNG";
 277          break;
 278       case N8_EA:
 279          ret = "N8_EA";
 280          break;
 281       case N8_NUM_COMPONENTS:
 282          ret = "N8_NUM_COMPONENTS";
 283          break;
 284       default:
 285          ret = "Invalid enumeration value for N8_Component_t";
 286    }
 287
 288    return ret;
 289 }   /* N8_Component_t_text */
 290
 291 /*****************************************************************************/
 292 const char * N8_KeyType_t_text(const N8_KeyType_t enumValue)
 293 {
 294    const char *ret;
 295    switch (enumValue)
 296    {
 297       case N8_PUBLIC:
 298          ret = "N8_PUBLIC";
 299          break;
 300       case N8_PRIVATE:
 301          ret = "N8_PRIVATE";
 302          break;
 303       case N8_PRIVATE_CRT:
 304          ret = "N8_PRIVATE_CRT";
 305          break;
 306       case N8_PRIVATE_SKS:
 307          ret = "N8_PRIVATE_SKS";
 308          break;
 309       default:
 310          ret = "Invalid enumeration value for N8_KeyType_t";
 311    }
 312
 313    return ret;
 314 }   /* N8_KeyType_t_text */
 315
 316 /*****************************************************************************/
 317 const char * N8_HashRole_t_text(const N8_HashRole_t enumValue)
 318 {
 319    const char *ret;
 320    switch (enumValue)
 321    {
 322       case N8_SERVER:
 323          ret = "N8_SERVER";
 324          break;
 325       case N8_CLIENT:
 326          ret = "N8_CLIENT";
 327          break;
 328       default:
 329          ret = "Invalid enumeration value for N8_HashRole_t";
 330    }
 331
 332    return ret;
 333 }   /* N8_HashRole_t_text */
 334
 335 /*****************************************************************************/
 336 const char * N8_Parameter_t_text(const N8_Parameter_t enumValue)
 337 {
 338    const char *ret;
 339    switch (enumValue)
 340    {
 341       case N8_EACOUNT:
 342          ret = "N8_EACOUNT";
 343          break;
 344       case N8_EATYPE:
 345          ret = "N8_EATYPE";
 346          break;
 347       case N8_PKCOUNT:
 348          ret = "N8_PKCOUNT";
 349          break;
 350       case N8_PKTYPE:
 351          ret = "N8_PKTYPE";
 352          break;
 353       case N8_HPCOUNT:
 354          ret = "N8_HPCOUNT";
 355          break;
 356       case N8_HPTYPE:
 357          ret = "N8_HPTYPE";
 358          break;
 359       case N8_HARDWAREVERSION:
 360          ret = "N8_HARDWAREVERSION";
 361          break;
 362       case N8_SOFTWAREVERSION:
 363          ret = "N8_SOFTWAREVERSION";
 364          break;
 365       case N8_CONTEXTMEMSIZE:
 366          ret = "N8_CONTEXTMEMSIZE";
 367          break;
 368       case N8_SKSMEMSIZE:
 369          ret = "N8_SKSMEMSIZE";
 370          break;
 371       case N8_NUMBEROFCHIPS:
 372          ret = "N8_NUMBEROFCHIPS";
 373          break;
 374       case N8_SWVERSIONTEXT:
 375          ret = "N8_SWVERSIONTEXT";
 376          break;
 377       case N8_FILEDESCRIPTOR:
 378          ret = "N8_FILEDESCRIPTOR";
 379          break;
 380       case N8_INITIALIZE_INFO:
 381          ret = "N8_INITIALIZE_INFO";
 382          break;
 383       case N8_HARDWAREREVISION:
 384          ret = "N8_HARDWAREREVISION";
 385          break;
 386       default:
 387          ret = "Invalid enumeration value for N8_Parameter_t";
 388    }
 389
 390    return ret;
 391 }   /* N8_Parameter_t_text */
 392
 393 /*****************************************************************************/
 394 const char * N8_Boolean_t_text(const N8_Boolean_t enumValue)
 395 {
 396    const char *ret;
 397    switch (enumValue)
 398    {
 399       case N8_FALSE:
 400          ret = "N8_FALSE";
 401          break;
 402       case N8_TRUE:
 403          ret = "N8_TRUE";
 404          break;
 405       default:
 406          ret = "Invalid enumeration value for N8_Boolean_t";
 407    }
 408
 409    return ret;
 410 }   /* N8_Boolean_t_text */
 411
 412 /*****************************************************************************/
 413 const char * N8_Protocol_t_text(const N8_Protocol_t enumValue)
 414 {
 415    const char *ret;
 416    switch (enumValue)
 417    {
 418       case N8_PROTOCOL_SSL:
 419          ret = "N8_PROTOCOL_SSL";
 420          break;
 421       case N8_PROTOCOL_TLS:
 422          ret = "N8_PROTOCOL_TLS";
 423          break;
 424       case N8_PROTOCOL_IPSEC:
 425          ret = "N8_PROTOCOL_IPSEC";
 426          break;
 427       default:
 428          ret = "Invalid enumeration value for N8_Protocol_t";
 429    }
 430
 431    return ret;
 432 }   /* N8_Protocol_t_text */
 433
 434 /*****************************************************************************/
 435 const char * N8_PacketMemoryMode_t_text(const N8_PacketMemoryMode_t enumValue)
 436 {
 437    const char *ret;
 438    switch (enumValue)
 439    {
 440       case N8_PACKETMEMORY_NONE:
 441          ret = "N8_PACKETMEMORY_NONE";
 442          break;
 443       case N8_PACKETMEMORY_REQUEST:
 444          ret = "N8_PACKETMEMORY_REQUEST";
 445          break;
 446       default:
 447          ret = "Invalid enumeration value for N8_PacketMemoryMode_t";
 448    }
 449
 450    return ret;
 451 }   /* N8_PacketMemoryMode_t_text */
 452
 453 /*****************************************************************************/
 454 const char * N8_HashAlgorithm_t_text(const N8_HashAlgorithm_t enumValue)
 455 {
 456    const char *ret;
 457    switch (enumValue)
 458    {
 459       case N8_MD5:
 460          ret = "N8_MD5";
 461          break;
 462       case N8_SHA1:
 463          ret = "N8_SHA1";
 464          break;
 465       case N8_HMAC_MD5:
 466          ret = "N8_HMAC_MD5";
 467          break;
 468       case N8_HMAC_SHA1:
 469          ret = "N8_HMAC_SHA1";
 470          break;
 471       case N8_HMAC_MD5_96:
 472          ret = "N8_HMAC_MD5_96";
 473          break;
 474       case N8_HMAC_SHA1_96:
 475          ret = "N8_HMAC_SHA1_96";
 476          break;
 477       case N8_HASH_NONE:
 478          ret = "N8_HASH_NONE";
 479          break;
 480       default:
 481          ret = "Invalid enumeration value for N8_HashAlgorithm_t";
 482    }
 483
 484    return ret;
 485 }   /* N8_HashAlgorithm_t_text */
 486
 487 /*****************************************************************************/
 488 const char * N8_MemoryType_t_text(const N8_MemoryType_t enumValue)
 489 {
 490    const char *ret;
 491    switch (enumValue)
 492    {
 493       case N8_MEMBANK_QUEUE:
 494          ret = "N8_MEMBANK_QUEUE";
 495          break;
 496       case N8_MEMBANK_EA:
 497          ret = "N8_MEMBANK_EA";
 498          break;
 499       case N8_MEMBANK_PK:
 500          ret = "N8_MEMBANK_PK";
 501          break;
 502       case N8_MEMBANK_USERPOOL:
 503          ret = "N8_MEMBANK_USERPOOL";
 504          break;
 505       case N8_MEMBANK_MAX:
 506          ret = "N8_MEMBANK_MAX";
 507          break;
 508       default:
 509          ret = "Invalid enumeration value for N8_MemoryType_t";
 510    }
 511
 512    return ret;
 513 }   /* N8_MemoryType_t_text */
 514