1 /***************************************************************************//** 2 * @file 3 * @brief Silicon Labs Secure Engine Manager API types 4 ******************************************************************************* 5 * # License 6 * <b>Copyright 2020 Silicon Laboratories Inc. www.silabs.com</b> 7 ******************************************************************************* 8 * 9 * SPDX-License-Identifier: Zlib 10 * 11 * The licensor of this software is Silicon Laboratories Inc. 12 * 13 * This software is provided 'as-is', without any express or implied 14 * warranty. In no event will the authors be held liable for any damages 15 * arising from the use of this software. 16 * 17 * Permission is granted to anyone to use this software for any purpose, 18 * including commercial applications, and to alter it and redistribute it 19 * freely, subject to the following restrictions: 20 * 21 * 1. The origin of this software must not be misrepresented; you must not 22 * claim that you wrote the original software. If you use this software 23 * in a product, an acknowledgment in the product documentation would be 24 * appreciated but is not required. 25 * 2. Altered source versions must be plainly marked as such, and must not be 26 * misrepresented as being the original software. 27 * 3. This notice may not be removed or altered from any source distribution. 28 * 29 ******************************************************************************/ 30 #ifndef SL_SE_MANAGER_TYPES_H 31 #define SL_SE_MANAGER_TYPES_H 32 33 #include "sli_se_manager_features.h" 34 35 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) || defined(SLI_VSE_MAILBOX_COMMAND_SUPPORTED) 36 37 /// @addtogroup sl_se_manager 38 /// @{ 39 40 #include "sl_se_manager_defines.h" 41 #include "sli_se_manager_mailbox.h" 42 #include <stdint.h> 43 #include <stdbool.h> 44 #include <stddef.h> 45 46 #ifdef __cplusplus 47 extern "C" { 48 #endif 49 50 // ----------------------------------------------------------------------------- 51 // Typedefs 52 53 /// @addtogroup sl_se_manager_util 54 /// @{ 55 56 /// OTP key types 57 typedef enum { 58 SL_SE_KEY_TYPE_IMMUTABLE_BOOT = 0, 59 SL_SE_KEY_TYPE_IMMUTABLE_AUTH, 60 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) 61 SL_SE_KEY_TYPE_IMMUTABLE_AES_128, 62 #if (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 63 SL_SE_KEY_TYPE_IMMUTABLE_ATTESTATION, 64 SL_SE_KEY_TYPE_IMMUTABLE_SE_ATTESTATION, 65 #endif // _SILICON_LABS_SECURITY_FEATURE_VAULT 66 #endif // SLI_MAILBOX_COMMAND_SUPPORTED 67 } sl_se_device_key_type_t; 68 69 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) && (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 70 /// SE tamper signal levels 71 typedef uint8_t sl_se_tamper_level_t; 72 73 /// SE tamper signals 74 typedef uint32_t sl_se_tamper_signals_t; 75 76 /// SE tamper filter timeout period 77 typedef uint8_t sl_se_tamper_filter_period_t; 78 79 /// Number of tamper counts to trigger the filter signal 80 typedef uint8_t sl_se_tamper_filter_threshold_t; 81 #endif // _SILICON_LABS_SECURITY_FEATURE_VAULT 82 83 /// Certificate size data structure 84 typedef struct { 85 uint32_t batch_id_size; ///< size in bytes of the Batch certificate 86 uint32_t se_id_size; ///< size in bytes of the SE ID certificate 87 uint32_t host_id_size; ///< size in bytes of the Host ID certificate 88 } sl_se_cert_size_type_t; 89 90 /// SE certificate types 91 typedef uint8_t sl_se_cert_type_t; 92 93 /// OTP initialization data structure 94 typedef struct { 95 /// Enable secure boot for the host. 96 bool enable_secure_boot; 97 /// Require certificate based secure boot signing. 98 bool verify_secure_boot_certificate; 99 /// Enable anti-rollback for host application upgrades. 100 bool enable_anti_rollback; 101 /// Set flag to enable locking down all flash pages that cover the 102 /// secure-booted image, except the last page if end of signature is not 103 /// page-aligned. 104 bool secure_boot_page_lock_narrow; 105 /// Set flag to enable locking down all flash pages that cover the 106 /// secure-booted image, including the last page if end of signature is not 107 /// page-aligned. 108 bool secure_boot_page_lock_full; 109 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) && (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 110 /// List of tamper levels to configure for the different tamper sources. 111 sl_se_tamper_level_t tamper_levels[SL_SE_TAMPER_SIGNAL_NUM_SIGNALS]; 112 /// Reset period for the tamper filter counter. 113 sl_se_tamper_filter_period_t tamper_filter_period; 114 /// Activation threshold for the tamper filter. 115 sl_se_tamper_filter_threshold_t tamper_filter_threshold; 116 /// Tamper flags. 117 uint8_t tamper_flags; 118 /// Tamper reset halt threshold. 119 uint8_t tamper_reset_threshold; 120 #endif // _SILICON_LABS_SECURITY_FEATURE_VAULT 121 } sl_se_otp_init_t; 122 123 /// @} (end addtogroup sl_se_manager_util) 124 125 /// @addtogroup sl_se_manager_core 126 /// @{ 127 128 /***************************************************************************//** 129 * @brief SE mailbox command context 130 * 131 * @details 132 * This structure defines the common SE mailbox command context used for 133 * all SE Manager API functions that execute SE mailbox commands. The 134 * members of this context structure should be considered internal to the 135 * SE Manager and should not be read or written directly by the user 136 * application. For members that are relevant for the user, the user can 137 * access them via corresponding set and get API functions, e.g. 138 * sl_se_set_yield(). 139 ******************************************************************************/ 140 typedef struct sl_se_command_context_t { 141 sli_se_mailbox_command_t command; ///< SE mailbox command struct 142 bool yield; ///< If true, yield the CPU core while 143 ///< waiting for the SE mailbox command 144 ///< to complete. If false, busy-wait, by 145 ///< polling the SE mailbox response 146 ///< register. 147 } sl_se_command_context_t; 148 149 /// @} (end addtogroup sl_se_manager_core) 150 151 /// @addtogroup sl_se_manager_util 152 /// @{ 153 154 /// SE Debug lock flags 155 typedef uint32_t sl_se_debug_flags_t; 156 157 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) 158 /// Debug lock options 159 typedef struct { 160 /// Non-Secure, Invasive debug access enabled if true. If false, it is not 161 /// possible to debug the non-secure state in a way that is intrusive to 162 /// program execution (DBGLOCK locked). 163 bool non_secure_invasive_debug; 164 /// Non-Secure, Non-Invasive debug access enabled if true. If false, it is 165 /// not possible to debug the non-secure state in a way that is intrusive to 166 /// program execution (NIDLOCK locked). 167 bool non_secure_non_invasive_debug; 168 /// Secure, Invasive debug access enabled if true. If false, it is not 169 /// possible to debug the secure TrustZone state in a way that is intrusive 170 /// to program execution (SPIDLOCK locked). 171 bool secure_invasive_debug; 172 /// Secure, Non-Invasive debug access enabled if true. If false, it is not 173 /// possible to observe the secure TrustZone state using trace. 174 /// (SPNIDLOCK is locked. However if SPIDLOCK is open, SPNIDLOCK will also 175 /// remain open.) 176 bool secure_non_invasive_debug; 177 } sl_se_debug_options_t; 178 #endif 179 180 /// Debug status 181 typedef struct { 182 /// Whether device erase is enabled 183 bool device_erase_enabled; 184 /// Whether secure debug is enabled with @ref sl_se_enable_secure_debug(). 185 bool secure_debug_enabled; 186 /// Whether the debug port has been locked with @ref sl_se_apply_debug_lock(). 187 /// This parameter does not indicate if the debug port has been unlocked by 188 /// calling @ref sl_se_open_debug(). 189 bool debug_port_lock_applied; 190 /// Current state of the debug port. 191 /// True if locked with @ref sl_se_apply_debug_lock(). 192 /// False if new clean, erased or unlocked with @ref sl_se_open_debug(). 193 bool debug_port_lock_state; 194 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) 195 /// Debug option configuration as set by @ref sl_se_set_debug_options(). 196 sl_se_debug_options_t options_config; 197 /// Current state of debug options, locked by @ref sl_se_set_debug_options() and 198 /// unlocked by @ref sl_se_open_debug(). 199 sl_se_debug_options_t options_state; 200 #endif 201 } sl_se_debug_status_t; 202 203 /// @} (end addtogroup sl_se_manager_util) 204 205 #if defined(SLI_MAILBOX_COMMAND_SUPPORTED) 206 207 /// @addtogroup sl_se_manager_key_handling 208 /// @{ 209 210 /// Supported key types 211 typedef uint32_t sl_se_key_type_t; 212 213 /// Key storage method. Can have one of @ref SL_SE_KEY_STORAGE_EXTERNAL_PLAINTEXT, 214 /// @ref SL_SE_KEY_STORAGE_EXTERNAL_WRAPPED, 215 /// @ref SL_SE_KEY_STORAGE_INTERNAL_VOLATILE or 216 /// @ref SL_SE_KEY_STORAGE_INTERNAL_IMMUTABLE. 217 typedef uint32_t sl_se_storage_method_t; 218 219 /// Internal SE key slot 220 typedef uint32_t sl_se_key_slot_t; 221 222 /// Describes where the key is or should be stored 223 typedef struct { 224 uint8_t* pointer; ///< Pointer to a key buffer. 225 uint32_t size; ///< Size of buffer. 226 } sl_se_buffer_t; 227 228 /// Describes the storage location of keys 229 typedef struct { 230 /// Key storage method. Sets meaning of data in location. 231 sl_se_storage_method_t method; 232 /// Describes key storage location. @ref sl_se_buffer_t is used if @ref sl_se_key_storage_t.method is 233 /// @ref SL_SE_KEY_STORAGE_EXTERNAL_PLAINTEXT or 234 /// @ref SL_SE_KEY_STORAGE_EXTERNAL_WRAPPED, while @ref sl_se_key_slot_t is 235 /// used for @ref SL_SE_KEY_STORAGE_INTERNAL_VOLATILE or 236 /// @ref SL_SE_KEY_STORAGE_INTERNAL_IMMUTABLE. 237 union { 238 sl_se_buffer_t buffer; 239 sl_se_key_slot_t slot; 240 } location; 241 } sl_se_key_storage_t; 242 243 /// Contains a full description of a key used by an SE command. 244 typedef struct { 245 /// Key type 246 sl_se_key_type_t type; 247 /// Key size, applicable if key_type == SYMMETRIC 248 size_t size; 249 /// Flags describing restrictions, permissions and attributes of the key. 250 uint32_t flags; 251 /// Storage location for this key 252 sl_se_key_storage_t storage; 253 /// Optional password for key usage (8 bytes). If no password is provided 254 /// (NULL pointer), any key not stored as plaintext will be stored with a 255 /// password of all-zero bytes. 256 uint8_t* password; 257 /// Pointer to domain descriptor if this key contains an asymmetric key on a 258 /// custom domain The reason for pointing instead of containing is to make 259 /// it possible to have the parameters in ROM. 260 const void* domain; 261 } sl_se_key_descriptor_t; 262 263 #if (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 264 /// Custom Weierstrass curve structure. 265 typedef struct { 266 /// Domain size in bytes. 267 const size_t size; 268 /// Modulus p (zero-padded from MSB, right-adjusted to extend to 32-bit 269 /// alignment up from domain size) 270 const uint8_t* p; 271 /// Order N (zero-padded from MSB, right-adjusted to extend to 32-bit 272 /// alignment up from domain size) 273 const uint8_t* N; 274 /// Generator X-coordinate (zero-padded from MSB, right-adjusted to extend 275 /// to 32-bit alignment up from domain size) 276 const uint8_t* Gx; 277 /// Generator Y-coordinate (zero-padded from MSB, right-adjusted to extend 278 /// to 32-bit alignment up from domain size) 279 const uint8_t* Gy; 280 /// Parameter a (zero-padded from MSB, right-adjusted to extend to 32-bit 281 /// alignment up from domain size) 282 const uint8_t* a; 283 /// Parameter b (zero-padded from MSB, right-adjusted to extend to 32-bit 284 /// alignment up from domain size) 285 const uint8_t* b; 286 /// Set if a equals 0 287 bool a_is_zero; 288 /// Set if a equals -3 289 bool a_is_minus_three; 290 } sl_se_custom_weierstrass_prime_domain_t; 291 #endif 292 293 /// @} (end addtogroup sl_se_manager_key_handling) 294 295 /// @addtogroup sl_se_manager_util 296 /// @{ 297 298 /// SE challenge storage 299 typedef uint8_t sl_se_challenge_t[SL_SE_CHALLENGE_SIZE]; 300 301 /// SE status 302 typedef struct { 303 /// Boot status code / error code (Bits [7:0]). 304 uint32_t boot_status; 305 /// SE firmware version. 306 uint32_t se_fw_version; 307 /// Host firmware version (if available). 308 uint32_t host_fw_version; 309 /// Debug lock status. 310 sl_se_debug_status_t debug_status; 311 /// Secure boot enabled. 312 bool secure_boot_enabled; 313 /// Active mode enabled. 314 bool active_mode_enabled; 315 /// Recorded tamper status. Reset on status read. 316 uint32_t tamper_status; 317 /// Currently active tamper sources. 318 uint32_t tamper_status_raw; 319 #if defined(_SILICON_LABS_32B_SERIES_3) 320 uint8_t rom_revision; 321 uint8_t otp_patch_sequence; 322 #endif 323 } sl_se_status_t; 324 325 /// @} (end addtogroup sl_se_manager_util) 326 327 /// @addtogroup sl_se_manager_cipher 328 /// @{ 329 330 /// Cipher operation types 331 typedef enum { 332 SL_SE_ENCRYPT, 333 SL_SE_DECRYPT 334 } sl_se_cipher_operation_t; 335 336 /// CMAC streaming context 337 typedef struct { 338 uint8_t state[16]; ///< CMAC state 339 uint8_t data_in[16]; ///< Unprocessed data 340 uint8_t data_out[16]; ///< Last 16 bytes of cipher-text 341 size_t length; ///< Length of all processed and unprocessed data 342 } sl_se_cmac_multipart_context_t; 343 344 /// CCM streaming context. 345 typedef struct { 346 uint32_t processed_message_length;///< Current length of the encrypted/decrypted data 347 uint32_t total_message_length; ///< Total length of data to be encrypted/decrypted 348 uint8_t iv[13]; ///< Nonce (MAX size is 13 bytes) 349 uint32_t tag_len; ///< Tag length 350 sl_se_cipher_operation_t mode;///< CCM mode (decrypt or encrypt) 351 #if defined(SLI_SE_MAJOR_VERSION_ONE) 352 uint8_t nonce_counter[16]; ///< Counter to keep CTR state 353 uint8_t iv_len; ///< Nonce length 354 uint8_t cbc_mac_state[16]; ///< State of authenication/MAC 355 uint8_t final_data[16]; ///< Input data saved for finish operation 356 #else 357 uint8_t se_ctx[32]; ///< SE encryption state 358 union { 359 uint8_t tagbuf[16]; ///< Tag 360 uint8_t final_data[16]; ///< Input data saved for finish operation 361 } mode_specific_buffer; ///< Buffer containing Tag and input data saved for finish operation 362 #endif 363 uint8_t final_data_length; ///< Length of data saved 364 } sl_se_ccm_multipart_context_t; 365 366 typedef struct { 367 uint64_t len; ///< Total length of the encrypted data 368 uint64_t add_len; ///< Total length of the additional data 369 #if defined(SLI_SE_MAJOR_VERSION_ONE) 370 uint8_t tagbuf[16]; ///< Tag 371 uint8_t previous_se_ctx[32]; ///< SE state from previous operation 372 #endif 373 uint8_t se_ctx[32]; ///< SE state 374 uint8_t final_data[16]; ///< Input data saved for finish operation 375 uint8_t final_data_length; ///< Length of data saved 376 sl_se_cipher_operation_t mode;///< GCM mode 377 bool first_operation; ///< First operation 378 } sl_se_gcm_multipart_context_t; 379 380 /// @} (end addtogroup sl_se_manager_cipher) 381 382 /// @addtogroup sl_se_manager_hash 383 /// @{ 384 385 /// Hash algorithms 386 typedef enum { 387 SL_SE_HASH_NONE, ///< No hash 388 SL_SE_HASH_SHA1, ///< SHA-1 389 SL_SE_HASH_SHA224, ///< SHA-224 390 SL_SE_HASH_SHA256, ///< SHA-256 391 #if (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 392 SL_SE_HASH_SHA384, ///< SHA-384 393 SL_SE_HASH_SHA512, ///< SHA-512 394 #endif 395 } sl_se_hash_type_t; 396 397 /// SHA-1 streaming context. 398 typedef struct { 399 sl_se_hash_type_t hash_type; ///< Hash streaming context 400 uint32_t total[2]; ///< number of bytes processed 401 uint8_t state[32]; ///< intermediate digest state 402 uint8_t buffer[64]; ///< data block being processed 403 } sl_se_sha1_multipart_context_t; 404 405 /// SHA-224 streaming context. 406 typedef struct { 407 sl_se_hash_type_t hash_type; ///< Hash streaming context 408 uint32_t total[2]; ///< Number of bytes processed 409 uint8_t state[32]; ///< Intermediate digest state 410 uint8_t buffer[64]; ///< Data block being processed 411 } sl_se_sha224_multipart_context_t; 412 413 /// SHA-256 streaming context. 414 typedef struct { 415 sl_se_hash_type_t hash_type; ///< Hash streaming context 416 uint32_t total[2]; ///< Number of bytes processed 417 uint8_t state[32]; ///< Intermediate digest state 418 uint8_t buffer[64]; ///< Data block being processed 419 } sl_se_sha256_multipart_context_t; 420 421 #if (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 422 /// SHA-384 streaming context. 423 typedef struct { 424 sl_se_hash_type_t hash_type; ///< Hash streaming context 425 uint32_t total[4]; ///< Number of bytes processed 426 uint8_t state[64]; ///< Intermediate digest state 427 uint8_t buffer[128]; ///< Data block being processed 428 } sl_se_sha384_multipart_context_t; 429 430 /// SHA-512 streaming context. 431 typedef struct { 432 sl_se_hash_type_t hash_type; ///< Hash streaming context 433 uint32_t total[4]; ///< Number of bytes processed 434 uint8_t state[64]; ///< Intermediate digest state 435 uint8_t buffer[128]; ///< Data block being processed 436 } sl_se_sha512_multipart_context_t; 437 438 #endif 439 440 /// @} (end addtogroup sl_se_manager_hash) 441 442 /// @addtogroup sl_se_manager_key_derivation 443 /// @{ 444 445 /// Roles in the EC J-PAKE exchange 446 typedef enum { 447 SL_SE_ECJPAKE_CLIENT = 0, ///< Client 448 SL_SE_ECJPAKE_SERVER, ///< Server 449 } sl_se_ecjpake_role_t; 450 451 /**************************************************************************//** 452 * EC J-PAKE context structure. 453 * 454 * J-PAKE is a symmetric protocol, except for the identifiers used in 455 * Zero-Knowledge Proofs, and the serialization of the second message 456 * (KeyExchange) as defined by the Thread spec. 457 * 458 * In order to benefit from this symmetry, we choose a different naming 459 * convention from the Thread v1.0 spec. Correspondance is indicated in the 460 * description as a pair C: client name, S: server name 461 *****************************************************************************/ 462 typedef struct { 463 sl_se_command_context_t *cmd_ctx; ///< Pointer to command context object 464 uint32_t curve_flags; ///< Curve flags to use 465 sl_se_ecjpake_role_t role; ///< Are we client or server? 466 467 char pwd[32]; ///< J-PAKE password 468 size_t pwd_len; ///< J-PAKE password length 469 470 uint8_t r[32]; ///< Random scalar for exchange 471 uint8_t Xm1[64]; ///< Our point 1 (round 1) 472 uint8_t Xm2[64]; ///< Our point 2 (round 1) 473 uint8_t Xp1[64]; ///< Their point 1 (round 1) 474 uint8_t Xp2[64]; ///< Their point 2 (round 1) 475 uint8_t Xp[64]; ///< Their point (round 2) 476 } sl_se_ecjpake_context_t; 477 478 #if (_SILICON_LABS_SECURITY_FEATURE == _SILICON_LABS_SECURITY_FEATURE_VAULT) 479 /// Typedef sl_se_pbkdf2_prf_type_t to sl_se_hash_type_t in order to maintain 480 /// backward compatibility. Defines for mapping the PRF identifiers to the 481 /// underlying hash enum values exists in sl_se_manager_defines.h. 482 typedef sl_se_hash_type_t sl_se_pbkdf2_prf_type_t; 483 #endif 484 485 /// @} (end addtogroup sl_se_manager_key_derivation) 486 487 #if defined(_SILICON_LABS_32B_SERIES_3) 488 489 /// @addtogroup sl_se_manager_extmem 490 /// @{ 491 492 /// SE Crypto algorithms (ciphers, AEADs, MACs, hashes, etc) used for 493 /// the code region write function. 494 typedef enum { 495 SL_SE_ALG_AES_CTR, ///< Counter mode AES cipher 496 SL_SE_ALG_SHA_256, ///< SHA2-256 497 } sl_se_crypto_alg_t; 498 499 typedef struct { 500 sl_se_cipher_operation_t mode; ///< encryption or decryption 501 sl_se_key_descriptor_t *key; ///< Key to be used for encryption or decryption 502 unsigned char *iv; ///< Initial Vector/Nonce 503 size_t iv_len; ///< Initial Vector/Nonce length 504 unsigned char *add; ///< Additional data 505 size_t add_len; ///< Additional data length 506 unsigned char *tag; ///< Tag 507 size_t tag_len; ///< Tag length 508 } sl_se_aead_info_t; 509 510 typedef struct { 511 sl_se_cipher_operation_t mode; ///< encryption or decryption 512 sl_se_key_descriptor_t *key; ///< Key to be used for encryption or decryption 513 } sl_se_cipher_info_t; 514 515 typedef struct { 516 unsigned char *digest; ///< Pointer to message digest buffer 517 size_t digest_size; ///< Size of message digest 518 } sl_se_hash_info_t; 519 520 typedef union { 521 sl_se_aead_info_t aead; 522 sl_se_cipher_info_t cipher; 523 sl_se_hash_info_t hash; 524 } sl_se_crypto_alg_specific_info_t; 525 526 /// Information associated with cryupto related operations 527 typedef struct { 528 sl_se_crypto_alg_t *alg; ///< SE Crypto algorithm 529 sl_se_crypto_alg_specific_info_t alg_specific_info; 530 } sl_se_crypto_operation_t; 531 532 /// Security level of code region 533 typedef enum { 534 SL_SE_CODE_REGION_SECURITY_LEVEL_PLAINTEXT = 0, 535 SL_SE_CODE_REGION_SECURITY_LEVEL_ENC_ONLY, 536 SL_SE_CODE_REGION_SECURITY_LEVEL_ENC_AUTH, 537 } sl_se_code_region_security_level_t; 538 539 /// Code region configuration 540 typedef struct { 541 unsigned int region_idx; ///< Index of code region 542 unsigned int region_size; ///< Size of code region 543 sl_se_code_region_security_level_t security_level; ///< Security level of region 544 bool bank_swapping_enabled; ///< Bank swapping enabled (if true) 545 bool locked; ///< Region is locked (if true) 546 } sl_code_region_config_t; 547 548 /// @} (end addtogroup sl_se_manager_extmem) 549 550 #endif // defined(_SILICON_LABS_32B_SERIES_3) 551 552 #endif // defined(SLI_MAILBOX_COMMAND_SUPPORTED) 553 554 #ifdef __cplusplus 555 } 556 #endif 557 558 /// @} (end addtogroup sl_se_manager) 559 560 #endif // defined(SLI_MAILBOX_COMMAND_SUPPORTED) || defined(SLI_VSE_MAILBOX_COMMAND_SUPPORTED) 561 562 #endif // SL_SE_MANAGER_TYPES_H 563
