mbed - The official Mbed 2 C/C++ SDK provides the softwa…

Users » mbed_official » Code » mbed

mbed official / mbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Dependents: hello SerialTestv11 SerialTestv12 Sierpinski ... more

mbed 2

This is the mbed 2 library. If you'd like to learn about Mbed OS please see the mbed-os docs.

TARGET_EFM32PG_STK3401/TARGET_Silicon_Labs/TARGET_EFM32/emlib/inc/em_crypto.h@156:ff21514d8981, 2017-11-08 (annotated)

Committer:: AnnaBridge
Date:: Wed Nov 08 17:18:06 2017 +0000
Revision:: 156:ff21514d8981
Child:: 159:7130f322cb7e

Reverting back to release 154 of the mbed library

Who changed what in which revision?

User	Revision	Line number	New contents of line
AnnaBridge	156:ff21514d8981	1	/*************************************************************************//
AnnaBridge	156:ff21514d8981	2	* @file em_crypto.h
AnnaBridge	156:ff21514d8981	3	* @brief Cryptography accelerator peripheral API
AnnaBridge	156:ff21514d8981	4	* @version 5.1.2
AnnaBridge	156:ff21514d8981	5	*******************************************************************************
AnnaBridge	156:ff21514d8981	6	* @section License
AnnaBridge	156:ff21514d8981	7	* <b>Copyright 2016 Silicon Laboratories, Inc. http://www.silabs.com</b>
AnnaBridge	156:ff21514d8981	8	*******************************************************************************
AnnaBridge	156:ff21514d8981	9	*
AnnaBridge	156:ff21514d8981	10	* Permission is granted to anyone to use this software for any purpose,
AnnaBridge	156:ff21514d8981	11	* including commercial applications, and to alter it and redistribute it
AnnaBridge	156:ff21514d8981	12	* freely, subject to the following restrictions:
AnnaBridge	156:ff21514d8981	13	*
AnnaBridge	156:ff21514d8981	14	* 1. The origin of this software must not be misrepresented; you must not
AnnaBridge	156:ff21514d8981	15	* claim that you wrote the original software.
AnnaBridge	156:ff21514d8981	16	* 2. Altered source versions must be plainly marked as such, and must not be
AnnaBridge	156:ff21514d8981	17	* misrepresented as being the original software.
AnnaBridge	156:ff21514d8981	18	* 3. This notice may not be removed or altered from any source distribution.
AnnaBridge	156:ff21514d8981	19	*
AnnaBridge	156:ff21514d8981	20	* DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
AnnaBridge	156:ff21514d8981	21	* obligation to support this Software. Silicon Labs is providing the
AnnaBridge	156:ff21514d8981	22	* Software "AS IS", with no express or implied warranties of any kind,
AnnaBridge	156:ff21514d8981	23	* including, but not limited to, any implied warranties of merchantability
AnnaBridge	156:ff21514d8981	24	* or fitness for any particular purpose or warranties against infringement
AnnaBridge	156:ff21514d8981	25	* of any proprietary rights of a third party.
AnnaBridge	156:ff21514d8981	26	*
AnnaBridge	156:ff21514d8981	27	* Silicon Labs will not be liable for any consequential, incidental, or
AnnaBridge	156:ff21514d8981	28	* special damages, or any other relief, or for any claim by any third party,
AnnaBridge	156:ff21514d8981	29	* arising from your use of this Software.
AnnaBridge	156:ff21514d8981	30	*
AnnaBridge	156:ff21514d8981	31	******************************************************************************/
AnnaBridge	156:ff21514d8981	32	#ifndef EM_CRYPTO_H
AnnaBridge	156:ff21514d8981	33	#define EM_CRYPTO_H
AnnaBridge	156:ff21514d8981	34
AnnaBridge	156:ff21514d8981	35	#include "em_device.h"
AnnaBridge	156:ff21514d8981	36
AnnaBridge	156:ff21514d8981	37	#if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0)
AnnaBridge	156:ff21514d8981	38
AnnaBridge	156:ff21514d8981	39	#include "em_bus.h"
AnnaBridge	156:ff21514d8981	40	#include <stdbool.h>
AnnaBridge	156:ff21514d8981	41
AnnaBridge	156:ff21514d8981	42	#ifdef __cplusplus
AnnaBridge	156:ff21514d8981	43	extern "C" {
AnnaBridge	156:ff21514d8981	44	#endif
AnnaBridge	156:ff21514d8981	45
AnnaBridge	156:ff21514d8981	46	/*************************************************************************//
AnnaBridge	156:ff21514d8981	47	* @addtogroup emlib
AnnaBridge	156:ff21514d8981	48	* @{
AnnaBridge	156:ff21514d8981	49	******************************************************************************/
AnnaBridge	156:ff21514d8981	50
AnnaBridge	156:ff21514d8981	51	/*************************************************************************//
AnnaBridge	156:ff21514d8981	52	* @addtogroup CRYPTO
AnnaBridge	156:ff21514d8981	53	*
AnnaBridge	156:ff21514d8981	54	* @brief Cryptography accelerator peripheral API
AnnaBridge	156:ff21514d8981	55	*
AnnaBridge	156:ff21514d8981	56	* @details
AnnaBridge	156:ff21514d8981	57	* In order for cryptographic support, users are recommended to consider the
AnnaBridge	156:ff21514d8981	58	* crypto APIs of the mbedTLS library provided by Silicon Labs instead of the
AnnaBridge	156:ff21514d8981	59	* interface provided in em_crypto.h. The mbedTLS library provides a much
AnnaBridge	156:ff21514d8981	60	* richer crypto API, including hardware acceleration of several functions.
AnnaBridge	156:ff21514d8981	61	*
AnnaBridge	156:ff21514d8981	62	* The main purpose of em_crypto.h is to implement a thin software interface
AnnaBridge	156:ff21514d8981	63	* for the CRYPTO hardware functions especially for the accelerated APIs of
AnnaBridge	156:ff21514d8981	64	* the mbedTLS library. Additionally em_crypto.h implement the AES API of the
AnnaBridge	156:ff21514d8981	65	* em_aes.h (supported by classic EFM32) for backwards compatibility. The
AnnaBridge	156:ff21514d8981	66	* following list summarizes the em_crypto.h inteface:
AnnaBridge	156:ff21514d8981	67	* @li AES (Advanced Encryption Standard) @ref crypto_aes
AnnaBridge	156:ff21514d8981	68	* @li SHA (Secure Hash Algorithm) @ref crypto_sha
AnnaBridge	156:ff21514d8981	69	* @li Big Integer multiplier @ref crypto_mul
AnnaBridge	156:ff21514d8981	70	* @li Functions for loading data and executing instruction sequences @ref crypto_exec
AnnaBridge	156:ff21514d8981	71	*
AnnaBridge	156:ff21514d8981	72	* @n @section crypto_aes AES
AnnaBridge	156:ff21514d8981	73	* The AES APIs include support for AES-128 and AES-256 with block cipher
AnnaBridge	156:ff21514d8981	74	* modes:
AnnaBridge	156:ff21514d8981	75	* @li CBC - Cipher Block Chaining mode
AnnaBridge	156:ff21514d8981	76	* @li CFB - Cipher Feedback mode
AnnaBridge	156:ff21514d8981	77	* @li CTR - Counter mode
AnnaBridge	156:ff21514d8981	78	* @li ECB - Electronic Code Book mode
AnnaBridge	156:ff21514d8981	79	* @li OFB - Output Feedback mode
AnnaBridge	156:ff21514d8981	80	*
AnnaBridge	156:ff21514d8981	81	* For the AES APIs Input/output data (plaintext, ciphertext, key etc) are
AnnaBridge	156:ff21514d8981	82	* treated as byte arrays, starting with most significant byte. Ie, 32 bytes
AnnaBridge	156:ff21514d8981	83	* of plaintext (B0...B31) is located in memory in the same order, with B0 at
AnnaBridge	156:ff21514d8981	84	* the lower address and B31 at the higher address.
AnnaBridge	156:ff21514d8981	85	*
AnnaBridge	156:ff21514d8981	86	* Byte arrays must always be a multiple of AES block size, ie. a multiple
AnnaBridge	156:ff21514d8981	87	* of 16. Padding, if required, is done at the end of the byte array.
AnnaBridge	156:ff21514d8981	88	*
AnnaBridge	156:ff21514d8981	89	* Byte arrays should be word (32 bit) aligned for performance
AnnaBridge	156:ff21514d8981	90	* considerations, since the array is accessed with 32 bit access type.
AnnaBridge	156:ff21514d8981	91	* The core MCUs supports unaligned accesses, but with a performance penalty.
AnnaBridge	156:ff21514d8981	92	*
AnnaBridge	156:ff21514d8981	93	* It is possible to specify the same output buffer as input buffer as long
AnnaBridge	156:ff21514d8981	94	* as they point to the same address. In that case the provided input buffer
AnnaBridge	156:ff21514d8981	95	* is replaced with the encrypted/decrypted output. Notice that the buffers
AnnaBridge	156:ff21514d8981	96	* must be exactly overlapping. If partly overlapping, the behavior is
AnnaBridge	156:ff21514d8981	97	* undefined.
AnnaBridge	156:ff21514d8981	98	*
AnnaBridge	156:ff21514d8981	99	* It is up to the user to use a cipher mode according to its requirements
AnnaBridge	156:ff21514d8981	100	* in order to not break security. Please refer to specific cipher mode
AnnaBridge	156:ff21514d8981	101	* theory for details.
AnnaBridge	156:ff21514d8981	102	*
AnnaBridge	156:ff21514d8981	103	* References:
AnnaBridge	156:ff21514d8981	104	* @li Wikipedia - Cipher modes, http://en.wikipedia.org/wiki/Cipher_modes
AnnaBridge	156:ff21514d8981	105	*
AnnaBridge	156:ff21514d8981	106	* @li Recommendation for Block Cipher Modes of Operation,
AnnaBridge	156:ff21514d8981	107	* NIST Special Publication 800-38A, 2001 Edition,
AnnaBridge	156:ff21514d8981	108	* http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
AnnaBridge	156:ff21514d8981	109	*
AnnaBridge	156:ff21514d8981	110	* @li Recommendation for Block Cipher Modes of Operation,
AnnaBridge	156:ff21514d8981	111	* http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
AnnaBridge	156:ff21514d8981	112	*
AnnaBridge	156:ff21514d8981	113	* @n @section crypto_sha SHA
AnnaBridge	156:ff21514d8981	114	* The SHA APIs include support for
AnnaBridge	156:ff21514d8981	115	* @li SHA-1 @ref CRYPTO_SHA_1
AnnaBridge	156:ff21514d8981	116	* @li SHA-256 @ref CRYPTO_SHA_256
AnnaBridge	156:ff21514d8981	117	*
AnnaBridge	156:ff21514d8981	118	* The SHA-1 implementation is FIPS-180-1 compliant, ref:
AnnaBridge	156:ff21514d8981	119	* @li Wikipedia - SHA-1, https://en.wikipedia.org/wiki/SHA-1
AnnaBridge	156:ff21514d8981	120	* @li SHA-1 spec - http://www.itl.nist.gov/fipspubs/fip180-1.htm
AnnaBridge	156:ff21514d8981	121	*
AnnaBridge	156:ff21514d8981	122	* The SHA-256 implementation is FIPS-180-2 compliant, ref:
AnnaBridge	156:ff21514d8981	123	* @li Wikipedia - SHA-2, https://en.wikipedia.org/wiki/SHA-2
AnnaBridge	156:ff21514d8981	124	* @li SHA-2 spec - http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
AnnaBridge	156:ff21514d8981	125	*
AnnaBridge	156:ff21514d8981	126	* @n @section crypto_mul CRYPTO_Mul
AnnaBridge	156:ff21514d8981	127	* @ref CRYPTO_Mul is a function for multiplying big integers that are
AnnaBridge	156:ff21514d8981	128	* bigger than the operand size of the MUL instruction which is 128 bits.
AnnaBridge	156:ff21514d8981	129	* CRYPTO_Mul multiplies all partial operands of the input operands using
AnnaBridge	156:ff21514d8981	130	* MUL to form a resulting number which may be twice the size of
AnnaBridge	156:ff21514d8981	131	* the operands.
AnnaBridge	156:ff21514d8981	132	*
AnnaBridge	156:ff21514d8981	133	* CRPYTO_Mul is typically used by RSA implementations which perform a
AnnaBridge	156:ff21514d8981	134	* huge amount of multiplication and square operations in order to
AnnaBridge	156:ff21514d8981	135	* implement modular exponentiation.
AnnaBridge	156:ff21514d8981	136	* Some RSA implementations use a number representation including arrays
AnnaBridge	156:ff21514d8981	137	* of 32bit words of variable size. The user should compile with
AnnaBridge	156:ff21514d8981	138	* -D USE_VARIABLE_SIZED_DATA_LOADS in order to load these numbers
AnnaBridge	156:ff21514d8981	139	* directly into CRYPTO without converting the number representation.
AnnaBridge	156:ff21514d8981	140	*
AnnaBridge	156:ff21514d8981	141	* @n @section crypto_exec Load and Execute Instruction Sequences
AnnaBridge	156:ff21514d8981	142	* The functions for loading data and executing instruction sequences can
AnnaBridge	156:ff21514d8981	143	* be used to implement complex algorithms like elliptic curve cryptography
AnnaBridge	156:ff21514d8981	144	* (ECC)) and authenticated encryption algorithms. There are two typical
AnnaBridge	156:ff21514d8981	145	* modes of operation:
AnnaBridge	156:ff21514d8981	146	* @li Multi sequence operation
AnnaBridge	156:ff21514d8981	147	* @li Single static instruction sequence operation
AnnaBridge	156:ff21514d8981	148	*
AnnaBridge	156:ff21514d8981	149	* In multi sequence mode the software starts by loading input data, then
AnnaBridge	156:ff21514d8981	150	* an instruction sequence, execute, and finally read the result. This
AnnaBridge	156:ff21514d8981	151	* process is repeated until the full crypto operation is complete.
AnnaBridge	156:ff21514d8981	152	*
AnnaBridge	156:ff21514d8981	153	* When using a single static instruction sequence, there is just one
AnnaBridge	156:ff21514d8981	154	* instruction sequence which is loaded initially. The sequence can be setup
AnnaBridge	156:ff21514d8981	155	* to run multiple times. The data can be loaded during the execution of the
AnnaBridge	156:ff21514d8981	156	* sequence by using DMA, BUFC and/or programmed I/O directly from the MCU
AnnaBridge	156:ff21514d8981	157	* core. For details on how to program the instruction sequences please refer
AnnaBridge	156:ff21514d8981	158	* to the reference manual of the particular Silicon Labs device.
AnnaBridge	156:ff21514d8981	159	*
AnnaBridge	156:ff21514d8981	160	* In order to load input data to the CRYPTO module use any of the following
AnnaBridge	156:ff21514d8981	161	* functions:
AnnaBridge	156:ff21514d8981	162	* @li @ref CRYPTO_DataWrite - Write 128 bits to a DATA register.
AnnaBridge	156:ff21514d8981	163	* @li @ref CRYPTO_DDataWrite - Write 256 bits to a DDATA register.
AnnaBridge	156:ff21514d8981	164	* @li @ref CRYPTO_QDataWrite - Write 512 bits to a QDATA register.
AnnaBridge	156:ff21514d8981	165	*
AnnaBridge	156:ff21514d8981	166	* In order to read output data from the CRYPTO module use any of the
AnnaBridge	156:ff21514d8981	167	* following functions:
AnnaBridge	156:ff21514d8981	168	* @li @ref CRYPTO_DataRead - Read 128 bits from a DATA register.
AnnaBridge	156:ff21514d8981	169	* @li @ref CRYPTO_DDataRead - Read 256 bits from a DDATA register.
AnnaBridge	156:ff21514d8981	170	* @li @ref CRYPTO_QDataRead - Read 512 bits from a QDATA register.
AnnaBridge	156:ff21514d8981	171	*
AnnaBridge	156:ff21514d8981	172	* In order to load an instruction sequence to the CRYPTO module use
AnnaBridge	156:ff21514d8981	173	* @ref CRYPTO_InstructionSequenceLoad.
AnnaBridge	156:ff21514d8981	174	*
AnnaBridge	156:ff21514d8981	175	* In order to execute the current instruction sequence in the CRYPTO module
AnnaBridge	156:ff21514d8981	176	* use @ref CRYPTO_InstructionSequenceExecute.
AnnaBridge	156:ff21514d8981	177	*
AnnaBridge	156:ff21514d8981	178	* In order to check whether an instruction sequence has completed
AnnaBridge	156:ff21514d8981	179	* use @ref CRYPTO_InstructionSequenceDone.
AnnaBridge	156:ff21514d8981	180	*
AnnaBridge	156:ff21514d8981	181	* In order to wait for an instruction sequence to complete
AnnaBridge	156:ff21514d8981	182	* use @ref CRYPTO_InstructionSequenceWait.
AnnaBridge	156:ff21514d8981	183	*
AnnaBridge	156:ff21514d8981	184	* In order to optimally load (with regards to speed) and execute an
AnnaBridge	156:ff21514d8981	185	* instruction sequence use any of the CRYPTO_EXECUTE_X macros (where X is
AnnaBridge	156:ff21514d8981	186	* in the range 1-20) defined in @ref em_crypto.h. E.g. CRYPTO_EXECUTE_19.
AnnaBridge	156:ff21514d8981	187	* @{
AnnaBridge	156:ff21514d8981	188	******************************************************************************/
AnnaBridge	156:ff21514d8981	189
AnnaBridge	156:ff21514d8981	190	/*******************************************************************************
AnnaBridge	156:ff21514d8981	191	**************************** DEFINES *********************************
AnnaBridge	156:ff21514d8981	192	******************************************************************************/
AnnaBridge	156:ff21514d8981	193
AnnaBridge	156:ff21514d8981	194	/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
AnnaBridge	156:ff21514d8981	195	/** Data sizes used by CRYPTO operations. */
AnnaBridge	156:ff21514d8981	196	#define CRYPTO_DATA_SIZE_IN_BITS (128)
AnnaBridge	156:ff21514d8981	197	#define CRYPTO_DATA_SIZE_IN_BYTES (CRYPTO_DATA_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	198	#define CRYPTO_DATA_SIZE_IN_32BIT_WORDS (CRYPTO_DATA_SIZE_IN_BYTES/sizeof(uint32_t))
AnnaBridge	156:ff21514d8981	199
AnnaBridge	156:ff21514d8981	200	#define CRYPTO_KEYBUF_SIZE_IN_BITS (256)
AnnaBridge	156:ff21514d8981	201	#define CRYPTO_KEYBUF_SIZE_IN_BYTES (CRYPTO_DDATA_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	202	#define CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS (CRYPTO_DDATA_SIZE_IN_BYTES/sizeof(uint32_t))
AnnaBridge	156:ff21514d8981	203
AnnaBridge	156:ff21514d8981	204	#define CRYPTO_DDATA_SIZE_IN_BITS (256)
AnnaBridge	156:ff21514d8981	205	#define CRYPTO_DDATA_SIZE_IN_BYTES (CRYPTO_DDATA_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	206	#define CRYPTO_DDATA_SIZE_IN_32BIT_WORDS (CRYPTO_DDATA_SIZE_IN_BYTES/sizeof(uint32_t))
AnnaBridge	156:ff21514d8981	207
AnnaBridge	156:ff21514d8981	208	#define CRYPTO_QDATA_SIZE_IN_BITS (512)
AnnaBridge	156:ff21514d8981	209	#define CRYPTO_QDATA_SIZE_IN_BYTES (CRYPTO_QDATA_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	210	#define CRYPTO_QDATA_SIZE_IN_32BIT_WORDS (CRYPTO_QDATA_SIZE_IN_BYTES/sizeof(uint32_t))
AnnaBridge	156:ff21514d8981	211
AnnaBridge	156:ff21514d8981	212	#define CRYPTO_DATA260_SIZE_IN_32BIT_WORDS (9)
AnnaBridge	156:ff21514d8981	213
AnnaBridge	156:ff21514d8981	214	/** SHA-1 digest sizes */
AnnaBridge	156:ff21514d8981	215	#define CRYPTO_SHA1_DIGEST_SIZE_IN_BITS (160)
AnnaBridge	156:ff21514d8981	216	#define CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA1_DIGEST_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	217
AnnaBridge	156:ff21514d8981	218	/** SHA-256 digest sizes */
AnnaBridge	156:ff21514d8981	219	#define CRYPTO_SHA256_DIGEST_SIZE_IN_BITS (256)
AnnaBridge	156:ff21514d8981	220	#define CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA256_DIGEST_SIZE_IN_BITS/8)
AnnaBridge	156:ff21514d8981	221
AnnaBridge	156:ff21514d8981	222	/**
AnnaBridge	156:ff21514d8981	223	* Read and write all 260 bits of DDATA0 when in 260 bit mode.
AnnaBridge	156:ff21514d8981	224	*/
AnnaBridge	156:ff21514d8981	225	#define CRYPTO_DDATA0_260_BITS_READ(crypto, bigint260) CRYPTO_DData0Read260(crypto, bigint260)
AnnaBridge	156:ff21514d8981	226	#define CRYPTO_DDATA0_260_BITS_WRITE(crypto, bigint260) CRYPTO_DData0Write260(crypto, bigint260)
AnnaBridge	156:ff21514d8981	227	/** @endcond */
AnnaBridge	156:ff21514d8981	228
AnnaBridge	156:ff21514d8981	229	/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
AnnaBridge	156:ff21514d8981	230	/**
AnnaBridge	156:ff21514d8981	231	* Instruction sequence load macros CRYPTO_SEQ_LOAD_X (where X is in the range
AnnaBridge	156:ff21514d8981	232	* 1-20). E.g. @ref CRYPTO_SEQ_LOAD_20.
AnnaBridge	156:ff21514d8981	233	* Use these macros in order for faster execution than the function API.
AnnaBridge	156:ff21514d8981	234	*/
AnnaBridge	156:ff21514d8981	235	#define CRYPTO_SEQ_LOAD_1(crypto, a1) { \
AnnaBridge	156:ff21514d8981	236	crypto->SEQ0 = a1 \| (CRYPTO_CMD_INSTR_END<<8);}
AnnaBridge	156:ff21514d8981	237	#define CRYPTO_SEQ_LOAD_2(crypto, a1, a2) { \
AnnaBridge	156:ff21514d8981	238	crypto->SEQ0 = a1 \| (a2<<8) \| (CRYPTO_CMD_INSTR_END<<16);}
AnnaBridge	156:ff21514d8981	239	#define CRYPTO_SEQ_LOAD_3(crypto, a1, a2, a3) { \
AnnaBridge	156:ff21514d8981	240	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (CRYPTO_CMD_INSTR_END<<24);}
AnnaBridge	156:ff21514d8981	241	#define CRYPTO_SEQ_LOAD_4(crypto, a1, a2, a3, a4) { \
AnnaBridge	156:ff21514d8981	242	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	243	crypto->SEQ1 = CRYPTO_CMD_INSTR_END;}
AnnaBridge	156:ff21514d8981	244	#define CRYPTO_SEQ_LOAD_5(crypto, a1, a2, a3, a4, a5) { \
AnnaBridge	156:ff21514d8981	245	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	246	crypto->SEQ1 = a5 \| (CRYPTO_CMD_INSTR_END<<8);}
AnnaBridge	156:ff21514d8981	247	#define CRYPTO_SEQ_LOAD_6(crypto, a1, a2, a3, a4, a5, a6) { \
AnnaBridge	156:ff21514d8981	248	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	249	crypto->SEQ1 = a5 \| (a6<<8) \| (CRYPTO_CMD_INSTR_END<<16);}
AnnaBridge	156:ff21514d8981	250	#define CRYPTO_SEQ_LOAD_7(crypto, a1, a2, a3, a4, a5, a6, a7) { \
AnnaBridge	156:ff21514d8981	251	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	252	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (CRYPTO_CMD_INSTR_END<<24);}
AnnaBridge	156:ff21514d8981	253	#define CRYPTO_SEQ_LOAD_8(crypto, a1, a2, a3, a4, a5, a6, a7, a8) { \
AnnaBridge	156:ff21514d8981	254	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	255	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	256	crypto->SEQ2 = CRYPTO_CMD_INSTR_END;}
AnnaBridge	156:ff21514d8981	257	#define CRYPTO_SEQ_LOAD_9(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9) { \
AnnaBridge	156:ff21514d8981	258	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	259	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	260	crypto->SEQ2 = a9 \| (CRYPTO_CMD_INSTR_END<<8);}
AnnaBridge	156:ff21514d8981	261	#define CRYPTO_SEQ_LOAD_10(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { \
AnnaBridge	156:ff21514d8981	262	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	263	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	264	crypto->SEQ2 = a9 \| (a10<<8) \| (CRYPTO_CMD_INSTR_END<<16);}
AnnaBridge	156:ff21514d8981	265	#define CRYPTO_SEQ_LOAD_11(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { \
AnnaBridge	156:ff21514d8981	266	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	267	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	268	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (CRYPTO_CMD_INSTR_END<<24);}
AnnaBridge	156:ff21514d8981	269	#define CRYPTO_SEQ_LOAD_12(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { \
AnnaBridge	156:ff21514d8981	270	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	271	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	272	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	273	crypto->SEQ3 = CRYPTO_CMD_INSTR_END;}
AnnaBridge	156:ff21514d8981	274	#define CRYPTO_SEQ_LOAD_13(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { \
AnnaBridge	156:ff21514d8981	275	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	276	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	277	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	278	crypto->SEQ3 = a13 \| (CRYPTO_CMD_INSTR_END<<8);}
AnnaBridge	156:ff21514d8981	279	#define CRYPTO_SEQ_LOAD_14(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { \
AnnaBridge	156:ff21514d8981	280	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	281	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	282	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	283	crypto->SEQ3 = a13 \| (a14<<8) \| (CRYPTO_CMD_INSTR_END<<16);}
AnnaBridge	156:ff21514d8981	284	#define CRYPTO_SEQ_LOAD_15(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { \
AnnaBridge	156:ff21514d8981	285	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	286	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	287	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	288	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (CRYPTO_CMD_INSTR_END<<24);}
AnnaBridge	156:ff21514d8981	289	#define CRYPTO_SEQ_LOAD_16(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { \
AnnaBridge	156:ff21514d8981	290	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	291	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	292	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	293	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	294	crypto->SEQ4 = CRYPTO_CMD_INSTR_END;}
AnnaBridge	156:ff21514d8981	295	#define CRYPTO_SEQ_LOAD_17(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { \
AnnaBridge	156:ff21514d8981	296	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	297	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	298	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	299	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	300	crypto->SEQ4 = a17 \| (CRYPTO_CMD_INSTR_END<<8);}
AnnaBridge	156:ff21514d8981	301	#define CRYPTO_SEQ_LOAD_18(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { \
AnnaBridge	156:ff21514d8981	302	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	303	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	304	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	305	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	306	crypto->SEQ4 = a17 \| (a18<<8) \| (CRYPTO_CMD_INSTR_END<<16);}
AnnaBridge	156:ff21514d8981	307	#define CRYPTO_SEQ_LOAD_19(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { \
AnnaBridge	156:ff21514d8981	308	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	309	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	310	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	311	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	312	crypto->SEQ4 = a17 \| (a18<<8) \| (a19<<16) \| (CRYPTO_CMD_INSTR_END<<24);}
AnnaBridge	156:ff21514d8981	313	#define CRYPTO_SEQ_LOAD_20(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { \
AnnaBridge	156:ff21514d8981	314	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	315	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	316	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	317	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	318	crypto->SEQ4 = a17 \| (a18<<8) \| (a19<<16) \| (a20<<24);}
AnnaBridge	156:ff21514d8981	319	/** @endcond */
AnnaBridge	156:ff21514d8981	320
AnnaBridge	156:ff21514d8981	321	/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
AnnaBridge	156:ff21514d8981	322	/**
AnnaBridge	156:ff21514d8981	323	* Instruction sequence execution macros CRYPTO_EXECUTE_X (where X is in the range
AnnaBridge	156:ff21514d8981	324	* 1-20). E.g. @ref CRYPTO_EXECUTE_19.
AnnaBridge	156:ff21514d8981	325	* Use these macros in order for faster execution than the function API.
AnnaBridge	156:ff21514d8981	326	*/
AnnaBridge	156:ff21514d8981	327	#define CRYPTO_EXECUTE_1(crypto, a1) { \
AnnaBridge	156:ff21514d8981	328	crypto->SEQ0 = a1 \| (CRYPTO_CMD_INSTR_EXEC<<8); }
AnnaBridge	156:ff21514d8981	329	#define CRYPTO_EXECUTE_2(crypto, a1, a2) { \
AnnaBridge	156:ff21514d8981	330	crypto->SEQ0 = a1 \| (a2<<8) \| (CRYPTO_CMD_INSTR_EXEC<<16); }
AnnaBridge	156:ff21514d8981	331	#define CRYPTO_EXECUTE_3(crypto, a1, a2, a3) { \
AnnaBridge	156:ff21514d8981	332	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (CRYPTO_CMD_INSTR_EXEC<<24); }
AnnaBridge	156:ff21514d8981	333	#define CRYPTO_EXECUTE_4(crypto, a1, a2, a3, a4) { \
AnnaBridge	156:ff21514d8981	334	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	335	crypto->SEQ1 = CRYPTO_CMD_INSTR_EXEC; }
AnnaBridge	156:ff21514d8981	336	#define CRYPTO_EXECUTE_5(crypto, a1, a2, a3, a4, a5) { \
AnnaBridge	156:ff21514d8981	337	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	338	crypto->SEQ1 = a5 \| (CRYPTO_CMD_INSTR_EXEC<<8); }
AnnaBridge	156:ff21514d8981	339	#define CRYPTO_EXECUTE_6(crypto, a1, a2, a3, a4, a5, a6) { \
AnnaBridge	156:ff21514d8981	340	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	341	crypto->SEQ1 = a5 \| (a6<<8) \| (CRYPTO_CMD_INSTR_EXEC<<16); }
AnnaBridge	156:ff21514d8981	342	#define CRYPTO_EXECUTE_7(crypto, a1, a2, a3, a4, a5, a6, a7) { \
AnnaBridge	156:ff21514d8981	343	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	344	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (CRYPTO_CMD_INSTR_EXEC<<24); }
AnnaBridge	156:ff21514d8981	345	#define CRYPTO_EXECUTE_8(crypto, a1, a2, a3, a4, a5, a6, a7, a8) { \
AnnaBridge	156:ff21514d8981	346	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	347	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	348	crypto->SEQ2 = CRYPTO_CMD_INSTR_EXEC; }
AnnaBridge	156:ff21514d8981	349	#define CRYPTO_EXECUTE_9(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9) { \
AnnaBridge	156:ff21514d8981	350	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	351	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	352	crypto->SEQ2 = a9 \| (CRYPTO_CMD_INSTR_EXEC<<8); }
AnnaBridge	156:ff21514d8981	353	#define CRYPTO_EXECUTE_10(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { \
AnnaBridge	156:ff21514d8981	354	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	355	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	356	crypto->SEQ2 = a9 \| (a10<<8) \| (CRYPTO_CMD_INSTR_EXEC<<16); }
AnnaBridge	156:ff21514d8981	357	#define CRYPTO_EXECUTE_11(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { \
AnnaBridge	156:ff21514d8981	358	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	359	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	360	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (CRYPTO_CMD_INSTR_EXEC<<24); }
AnnaBridge	156:ff21514d8981	361	#define CRYPTO_EXECUTE_12(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { \
AnnaBridge	156:ff21514d8981	362	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	363	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	364	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	365	crypto->SEQ3 = CRYPTO_CMD_INSTR_EXEC; }
AnnaBridge	156:ff21514d8981	366	#define CRYPTO_EXECUTE_13(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { \
AnnaBridge	156:ff21514d8981	367	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	368	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	369	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	370	crypto->SEQ3 = a13 \| (CRYPTO_CMD_INSTR_EXEC<<8); }
AnnaBridge	156:ff21514d8981	371	#define CRYPTO_EXECUTE_14(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { \
AnnaBridge	156:ff21514d8981	372	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	373	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	374	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	375	crypto->SEQ3 = a13 \| (a14<<8) \| (CRYPTO_CMD_INSTR_EXEC<<16); }
AnnaBridge	156:ff21514d8981	376	#define CRYPTO_EXECUTE_15(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { \
AnnaBridge	156:ff21514d8981	377	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	378	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	379	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	380	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (CRYPTO_CMD_INSTR_EXEC<<24); }
AnnaBridge	156:ff21514d8981	381	#define CRYPTO_EXECUTE_16(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { \
AnnaBridge	156:ff21514d8981	382	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	383	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	384	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	385	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	386	crypto->SEQ4 = CRYPTO_CMD_INSTR_EXEC; }
AnnaBridge	156:ff21514d8981	387	#define CRYPTO_EXECUTE_17(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { \
AnnaBridge	156:ff21514d8981	388	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	389	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	390	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	391	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	392	crypto->SEQ4 = a17 \| (CRYPTO_CMD_INSTR_EXEC<<8); }
AnnaBridge	156:ff21514d8981	393	#define CRYPTO_EXECUTE_18(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { \
AnnaBridge	156:ff21514d8981	394	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	395	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	396	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	397	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	398	crypto->SEQ4 = a17 \| (a18<<8) \| (CRYPTO_CMD_INSTR_EXEC<<16); }
AnnaBridge	156:ff21514d8981	399	#define CRYPTO_EXECUTE_19(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { \
AnnaBridge	156:ff21514d8981	400	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	401	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	402	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	403	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	404	crypto->SEQ4 = a17 \| (a18<<8) \| (a19<<16) \| (CRYPTO_CMD_INSTR_EXEC<<24); }
AnnaBridge	156:ff21514d8981	405	#define CRYPTO_EXECUTE_20(crypto, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { \
AnnaBridge	156:ff21514d8981	406	crypto->SEQ0 = a1 \| (a2<<8) \| (a3<<16) \| (a4<<24); \
AnnaBridge	156:ff21514d8981	407	crypto->SEQ1 = a5 \| (a6<<8) \| (a7<<16) \| (a8<<24); \
AnnaBridge	156:ff21514d8981	408	crypto->SEQ2 = a9 \| (a10<<8) \| (a11<<16) \| (a12<<24); \
AnnaBridge	156:ff21514d8981	409	crypto->SEQ3 = a13 \| (a14<<8) \| (a15<<16) \| (a16<<24); \
AnnaBridge	156:ff21514d8981	410	crypto->SEQ4 = a17 \| (a18<<8) \| (a19<<16) \| (a20<<24); \
AnnaBridge	156:ff21514d8981	411	CRYPTO_InstructionSequenceExecute();}
AnnaBridge	156:ff21514d8981	412	/** @endcond */
AnnaBridge	156:ff21514d8981	413
AnnaBridge	156:ff21514d8981	414	/*******************************************************************************
AnnaBridge	156:ff21514d8981	415	**************************** TYPEDEFS *********************************
AnnaBridge	156:ff21514d8981	416	******************************************************************************/
AnnaBridge	156:ff21514d8981	417
AnnaBridge	156:ff21514d8981	418	/**
AnnaBridge	156:ff21514d8981	419	* CRYPTO data types used for data load functions. This data type is
AnnaBridge	156:ff21514d8981	420	* capable of storing a 128 bits value as used in the crypto DATA
AnnaBridge	156:ff21514d8981	421	* registers
AnnaBridge	156:ff21514d8981	422	*/
AnnaBridge	156:ff21514d8981	423	typedef uint32_t CRYPTO_Data_TypeDef[CRYPTO_DATA_SIZE_IN_32BIT_WORDS];
AnnaBridge	156:ff21514d8981	424
AnnaBridge	156:ff21514d8981	425	/**
AnnaBridge	156:ff21514d8981	426	* CRYPTO data type used for data load functions. This data type
AnnaBridge	156:ff21514d8981	427	* is capable of storing a 256 bits value as used in the crypto DDATA
AnnaBridge	156:ff21514d8981	428	* registers
AnnaBridge	156:ff21514d8981	429	*/
AnnaBridge	156:ff21514d8981	430	typedef uint32_t CRYPTO_DData_TypeDef[CRYPTO_DDATA_SIZE_IN_32BIT_WORDS];
AnnaBridge	156:ff21514d8981	431
AnnaBridge	156:ff21514d8981	432	/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
AnnaBridge	156:ff21514d8981	433	typedef uint32_t* CRYPTO_DDataPtr_TypeDef;
AnnaBridge	156:ff21514d8981	434	/** @endcond */
AnnaBridge	156:ff21514d8981	435
AnnaBridge	156:ff21514d8981	436	/**
AnnaBridge	156:ff21514d8981	437	* CRYPTO data type used for data load functions. This data type is
AnnaBridge	156:ff21514d8981	438	* capable of storing a 512 bits value as used in the crypto QDATA
AnnaBridge	156:ff21514d8981	439	* registers
AnnaBridge	156:ff21514d8981	440	*/
AnnaBridge	156:ff21514d8981	441	typedef uint32_t CRYPTO_QData_TypeDef[CRYPTO_QDATA_SIZE_IN_32BIT_WORDS];
AnnaBridge	156:ff21514d8981	442
AnnaBridge	156:ff21514d8981	443	/**
AnnaBridge	156:ff21514d8981	444	* CRYPTO data type used for data load functions. This data type is
AnnaBridge	156:ff21514d8981	445	* capable of storing a 260 bits value as used by the @ref CRYPTO_DData0Write260
AnnaBridge	156:ff21514d8981	446	* function.
AnnaBridge	156:ff21514d8981	447	*
AnnaBridge	156:ff21514d8981	448	* Note that this data type is multiple of 32 bit words, so the
AnnaBridge	156:ff21514d8981	449	* actual storage used by this type is 32x9=288 bits.
AnnaBridge	156:ff21514d8981	450	*/
AnnaBridge	156:ff21514d8981	451	typedef uint32_t CRYPTO_Data260_TypeDef[CRYPTO_DATA260_SIZE_IN_32BIT_WORDS];
AnnaBridge	156:ff21514d8981	452
AnnaBridge	156:ff21514d8981	453	/**
AnnaBridge	156:ff21514d8981	454	* CRYPTO data type used for data load functions. This data type is
AnnaBridge	156:ff21514d8981	455	* capable of storing 256 bits as used in the crypto KEYBUF register.
AnnaBridge	156:ff21514d8981	456	*/
AnnaBridge	156:ff21514d8981	457	typedef uint32_t CRYPTO_KeyBuf_TypeDef[CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS];
AnnaBridge	156:ff21514d8981	458
AnnaBridge	156:ff21514d8981	459	/**
AnnaBridge	156:ff21514d8981	460	* CRYPTO 128 bit Data register pointer type. The 128 bit registers are used to
AnnaBridge	156:ff21514d8981	461	* load 128 bit values as input and output data for cryptographic and big
AnnaBridge	156:ff21514d8981	462	* integer arithmetic functions of the CRYPTO module.
AnnaBridge	156:ff21514d8981	463	*/
AnnaBridge	156:ff21514d8981	464	typedef volatile uint32_t* CRYPTO_DataReg_TypeDef;
AnnaBridge	156:ff21514d8981	465
AnnaBridge	156:ff21514d8981	466	/**
AnnaBridge	156:ff21514d8981	467	* CRYPTO 256 bit DData (Double Data) register pointer type. The 256 bit
AnnaBridge	156:ff21514d8981	468	* registers are used to load 256 bit values as input and output data for
AnnaBridge	156:ff21514d8981	469	* cryptographic and big integer arithmetic functions of the CRYPTO module.
AnnaBridge	156:ff21514d8981	470	*/
AnnaBridge	156:ff21514d8981	471	typedef volatile uint32_t* CRYPTO_DDataReg_TypeDef;
AnnaBridge	156:ff21514d8981	472
AnnaBridge	156:ff21514d8981	473	/**
AnnaBridge	156:ff21514d8981	474	* CRYPTO 512 bit QData (Quad data) register pointer type. The 512 bit
AnnaBridge	156:ff21514d8981	475	* registers are used to load 512 bit values as input and output data for
AnnaBridge	156:ff21514d8981	476	* cryptographic and big integer arithmetic functions of the CRYPTO module.
AnnaBridge	156:ff21514d8981	477	*/
AnnaBridge	156:ff21514d8981	478	typedef volatile uint32_t* CRYPTO_QDataReg_TypeDef;
AnnaBridge	156:ff21514d8981	479
AnnaBridge	156:ff21514d8981	480	/** CRYPTO modulus identifiers. */
AnnaBridge	156:ff21514d8981	481	typedef enum
AnnaBridge	156:ff21514d8981	482	{
AnnaBridge	156:ff21514d8981	483	cryptoModulusBin256 = CRYPTO_WAC_MODULUS_BIN256, /*< Generic 256 bit modulus 2^256 /
AnnaBridge	156:ff21514d8981	484	cryptoModulusBin128 = CRYPTO_WAC_MODULUS_BIN128, /*< Generic 128 bit modulus 2^128 /
AnnaBridge	156:ff21514d8981	485	cryptoModulusGcmBin128 = CRYPTO_WAC_MODULUS_GCMBIN128, /*< GCM 128 bit modulus = 2^128 + 2^7 + 2^2 + 2 + 1 /
AnnaBridge	156:ff21514d8981	486	cryptoModulusEccB233 = CRYPTO_WAC_MODULUS_ECCBIN233P, /*< ECC B233 prime modulus = 2^233 + 2^74 + 1 /
AnnaBridge	156:ff21514d8981	487	cryptoModulusEccB163 = CRYPTO_WAC_MODULUS_ECCBIN163P, /*< ECC B163 prime modulus = 2^163 + 2^7 + 2^6 + 2^3 + 1 /
AnnaBridge	156:ff21514d8981	488	cryptoModulusEccP256 = CRYPTO_WAC_MODULUS_ECCPRIME256P, /*< ECC P256 prime modulus = 2^256 - 2^224 + 2^192 + 2^96 - 1 /
AnnaBridge	156:ff21514d8981	489	cryptoModulusEccP224 = CRYPTO_WAC_MODULUS_ECCPRIME224P, /*< ECC P224 prime modulus = 2^224 - 2^96 - 1 /
AnnaBridge	156:ff21514d8981	490	cryptoModulusEccP192 = CRYPTO_WAC_MODULUS_ECCPRIME192P, /*< ECC P192 prime modulus = 2^192 - 2^64 - 1 /
AnnaBridge	156:ff21514d8981	491	cryptoModulusEccB233Order = CRYPTO_WAC_MODULUS_ECCBIN233N, /*< ECC B233 order modulus /
AnnaBridge	156:ff21514d8981	492	cryptoModulusEccB233KOrder = CRYPTO_WAC_MODULUS_ECCBIN233KN, /*< ECC B233K order modulus /
AnnaBridge	156:ff21514d8981	493	cryptoModulusEccB163Order = CRYPTO_WAC_MODULUS_ECCBIN163N, /*< ECC B163 order modulus /
AnnaBridge	156:ff21514d8981	494	cryptoModulusEccB163KOrder = CRYPTO_WAC_MODULUS_ECCBIN163KN, /*< ECC B163K order modulus /
AnnaBridge	156:ff21514d8981	495	cryptoModulusEccP256Order = CRYPTO_WAC_MODULUS_ECCPRIME256N, /*< ECC P256 order modulus /
AnnaBridge	156:ff21514d8981	496	cryptoModulusEccP224Order = CRYPTO_WAC_MODULUS_ECCPRIME224N, /*< ECC P224 order modulus /
AnnaBridge	156:ff21514d8981	497	cryptoModulusEccP192Order = CRYPTO_WAC_MODULUS_ECCPRIME192N /*< ECC P192 order modulus /
AnnaBridge	156:ff21514d8981	498	} CRYPTO_ModulusId_TypeDef;
AnnaBridge	156:ff21514d8981	499
AnnaBridge	156:ff21514d8981	500	/** CRYPTO multiplication widths for wide arithmetic operations. */
AnnaBridge	156:ff21514d8981	501	typedef enum
AnnaBridge	156:ff21514d8981	502	{
AnnaBridge	156:ff21514d8981	503	cryptoMulOperand256Bits = CRYPTO_WAC_MULWIDTH_MUL256, /*< 256 bits operands /
AnnaBridge	156:ff21514d8981	504	cryptoMulOperand128Bits = CRYPTO_WAC_MULWIDTH_MUL128, /*< 128 bits operands /
AnnaBridge	156:ff21514d8981	505	cryptoMulOperandModulusBits = CRYPTO_WAC_MULWIDTH_MULMOD /**< MUL operand width
AnnaBridge	156:ff21514d8981	506	is specified by the
AnnaBridge	156:ff21514d8981	507	modulus type.*/
AnnaBridge	156:ff21514d8981	508	} CRYPTO_MulOperandWidth_TypeDef;
AnnaBridge	156:ff21514d8981	509
AnnaBridge	156:ff21514d8981	510	/** CRYPTO result widths for MUL operations. */
AnnaBridge	156:ff21514d8981	511	typedef enum
AnnaBridge	156:ff21514d8981	512	{
AnnaBridge	156:ff21514d8981	513	cryptoResult128Bits = CRYPTO_WAC_RESULTWIDTH_128BIT, /*< Multiplication result width is 128 bits/
AnnaBridge	156:ff21514d8981	514	cryptoResult256Bits = CRYPTO_WAC_RESULTWIDTH_256BIT, /*< Multiplication result width is 256 bits/
AnnaBridge	156:ff21514d8981	515	cryptoResult260Bits = CRYPTO_WAC_RESULTWIDTH_260BIT /*< Multiplication result width is 260 bits/
AnnaBridge	156:ff21514d8981	516	} CRYPTO_ResultWidth_TypeDef;
AnnaBridge	156:ff21514d8981	517
AnnaBridge	156:ff21514d8981	518	/** CRYPTO result widths for MUL operations. */
AnnaBridge	156:ff21514d8981	519	typedef enum
AnnaBridge	156:ff21514d8981	520	{
AnnaBridge	156:ff21514d8981	521	cryptoInc1byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH1, /*< inc width is 1 byte/
AnnaBridge	156:ff21514d8981	522	cryptoInc2byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH2, /*< inc width is 2 byte/
AnnaBridge	156:ff21514d8981	523	cryptoInc3byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH3, /*< inc width is 3 byte/
AnnaBridge	156:ff21514d8981	524	cryptoInc4byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH4 /*< inc width is 4 byte/
AnnaBridge	156:ff21514d8981	525	} CRYPTO_IncWidth_TypeDef;
AnnaBridge	156:ff21514d8981	526
AnnaBridge	156:ff21514d8981	527	/** CRYPTO key width. */
AnnaBridge	156:ff21514d8981	528	typedef enum
AnnaBridge	156:ff21514d8981	529	{
AnnaBridge	156:ff21514d8981	530	cryptoKey128Bits = 8, /*< Key width is 128 bits/
AnnaBridge	156:ff21514d8981	531	cryptoKey256Bits = 16, /*< Key width is 256 bits/
AnnaBridge	156:ff21514d8981	532	} CRYPTO_KeyWidth_TypeDef;
AnnaBridge	156:ff21514d8981	533
AnnaBridge	156:ff21514d8981	534	/**
AnnaBridge	156:ff21514d8981	535	* The max number of crypto instructions in an instruction sequence
AnnaBridge	156:ff21514d8981	536	*/
AnnaBridge	156:ff21514d8981	537	#define CRYPTO_MAX_SEQUENCE_INSTRUCTIONS (20)
AnnaBridge	156:ff21514d8981	538
AnnaBridge	156:ff21514d8981	539	/**
AnnaBridge	156:ff21514d8981	540	* Instruction sequence type.
AnnaBridge	156:ff21514d8981	541	* The user should fill in the desired operations from step1, then step2 etc.
AnnaBridge	156:ff21514d8981	542	* The CRYPTO_CMD_INSTR_END marks the end of the sequence.
AnnaBridge	156:ff21514d8981	543	* Bit fields are used to format the memory layout of the struct equal to the
AnnaBridge	156:ff21514d8981	544	* sequence registers in the CRYPTO module.
AnnaBridge	156:ff21514d8981	545	*/
AnnaBridge	156:ff21514d8981	546	typedef uint8_t CRYPTO_InstructionSequence_TypeDef[CRYPTO_MAX_SEQUENCE_INSTRUCTIONS];
AnnaBridge	156:ff21514d8981	547
AnnaBridge	156:ff21514d8981	548	/** Default instruction sequence consisting of all ENDs. The user can
AnnaBridge	156:ff21514d8981	549	initialize the instruction sequence with this default value set, and fill
AnnaBridge	156:ff21514d8981	550	in the desired operations from step 1. The first END instruction marks
AnnaBridge	156:ff21514d8981	551	the end of the sequence. */
AnnaBridge	156:ff21514d8981	552	#define CRYPTO_INSTRUCTIONSEQUENSE_DEFAULT \
AnnaBridge	156:ff21514d8981	553	{CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	554	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	555	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	556	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	557	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	558	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
AnnaBridge	156:ff21514d8981	559	CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END}
AnnaBridge	156:ff21514d8981	560
AnnaBridge	156:ff21514d8981	561	/** SHA-1 Digest type. */
AnnaBridge	156:ff21514d8981	562	typedef uint8_t CRYPTO_SHA1_Digest_TypeDef[CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES];
AnnaBridge	156:ff21514d8981	563
AnnaBridge	156:ff21514d8981	564	/** SHA-256 Digest type. */
AnnaBridge	156:ff21514d8981	565	typedef uint8_t CRYPTO_SHA256_Digest_TypeDef[CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES];
AnnaBridge	156:ff21514d8981	566
AnnaBridge	156:ff21514d8981	567	/**
AnnaBridge	156:ff21514d8981	568	* @brief
AnnaBridge	156:ff21514d8981	569	* AES counter modification function pointer.
AnnaBridge	156:ff21514d8981	570	*
AnnaBridge	156:ff21514d8981	571	* @note
AnnaBridge	156:ff21514d8981	572	* This is defined in order for backwards compatibility with EFM32 em_aes.h.
AnnaBridge	156:ff21514d8981	573	* The CRYPTO implementation of Counter mode does not support counter update
AnnaBridge	156:ff21514d8981	574	* callbacks.
AnnaBridge	156:ff21514d8981	575	*
AnnaBridge	156:ff21514d8981	576	* @param[in] ctr Counter value to be modified.
AnnaBridge	156:ff21514d8981	577	*/
AnnaBridge	156:ff21514d8981	578	typedef void (CRYPTO_AES_CtrFuncPtr_TypeDef)(uint8_t ctr);
AnnaBridge	156:ff21514d8981	579
AnnaBridge	156:ff21514d8981	580	/*******************************************************************************
AnnaBridge	156:ff21514d8981	581	*************************** PROTOTYPES ********************************
AnnaBridge	156:ff21514d8981	582	******************************************************************************/
AnnaBridge	156:ff21514d8981	583
AnnaBridge	156:ff21514d8981	584	/*************************************************************************//
AnnaBridge	156:ff21514d8981	585	* @brief
AnnaBridge	156:ff21514d8981	586	* Set the modulus type used for wide arithmetic operations.
AnnaBridge	156:ff21514d8981	587	*
AnnaBridge	156:ff21514d8981	588	* @details
AnnaBridge	156:ff21514d8981	589	* This function sets the modulus type to be used by the Modulus instructions
AnnaBridge	156:ff21514d8981	590	* of the CRYPTO module.
AnnaBridge	156:ff21514d8981	591	*
AnnaBridge	156:ff21514d8981	592	* @param[in] crypto
AnnaBridge	156:ff21514d8981	593	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	594	*
AnnaBridge	156:ff21514d8981	595	* @param[in] modType
AnnaBridge	156:ff21514d8981	596	* Modulus type.
AnnaBridge	156:ff21514d8981	597	******************************************************************************/
AnnaBridge	156:ff21514d8981	598	void CRYPTO_ModulusSet(CRYPTO_TypeDef * crypto,
AnnaBridge	156:ff21514d8981	599	CRYPTO_ModulusId_TypeDef modType);
AnnaBridge	156:ff21514d8981	600
AnnaBridge	156:ff21514d8981	601	/*************************************************************************//
AnnaBridge	156:ff21514d8981	602	* @brief
AnnaBridge	156:ff21514d8981	603	* Set the number of bits in the operands of the MUL instruction.
AnnaBridge	156:ff21514d8981	604	*
AnnaBridge	156:ff21514d8981	605	* @details
AnnaBridge	156:ff21514d8981	606	* This function sets the number of bits to be used in the operands of
AnnaBridge	156:ff21514d8981	607	* the MUL instruction.
AnnaBridge	156:ff21514d8981	608	*
AnnaBridge	156:ff21514d8981	609	* @param[in] crypto
AnnaBridge	156:ff21514d8981	610	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	611	*
AnnaBridge	156:ff21514d8981	612	* @param[in] mulOperandWidth
AnnaBridge	156:ff21514d8981	613	* Multiplication width in bits.
AnnaBridge	156:ff21514d8981	614	******************************************************************************/
AnnaBridge	156:ff21514d8981	615	__STATIC_INLINE
AnnaBridge	156:ff21514d8981	616	void CRYPTO_MulOperandWidthSet(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	617	CRYPTO_MulOperandWidth_TypeDef mulOperandWidth)
AnnaBridge	156:ff21514d8981	618	{
AnnaBridge	156:ff21514d8981	619	uint32_t temp = crypto->WAC & (~_CRYPTO_WAC_MULWIDTH_MASK);
AnnaBridge	156:ff21514d8981	620	crypto->WAC = temp \| mulOperandWidth;
AnnaBridge	156:ff21514d8981	621	}
AnnaBridge	156:ff21514d8981	622
AnnaBridge	156:ff21514d8981	623	/*************************************************************************//
AnnaBridge	156:ff21514d8981	624	* @brief
AnnaBridge	156:ff21514d8981	625	* Set the width of the results of the non-modulus instructions.
AnnaBridge	156:ff21514d8981	626	*
AnnaBridge	156:ff21514d8981	627	* @details
AnnaBridge	156:ff21514d8981	628	* This function sets the result width of the non-modulus instructions.
AnnaBridge	156:ff21514d8981	629	*
AnnaBridge	156:ff21514d8981	630	* @param[in] crypto
AnnaBridge	156:ff21514d8981	631	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	632	*
AnnaBridge	156:ff21514d8981	633	* @param[in] resultWidth
AnnaBridge	156:ff21514d8981	634	* Result width of non-modulus instructions.
AnnaBridge	156:ff21514d8981	635	******************************************************************************/
AnnaBridge	156:ff21514d8981	636	__STATIC_INLINE
AnnaBridge	156:ff21514d8981	637	void CRYPTO_ResultWidthSet(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	638	CRYPTO_ResultWidth_TypeDef resultWidth)
AnnaBridge	156:ff21514d8981	639	{
AnnaBridge	156:ff21514d8981	640	uint32_t temp = crypto->WAC & (~_CRYPTO_WAC_RESULTWIDTH_MASK);
AnnaBridge	156:ff21514d8981	641	crypto->WAC = temp \| resultWidth;
AnnaBridge	156:ff21514d8981	642	}
AnnaBridge	156:ff21514d8981	643
AnnaBridge	156:ff21514d8981	644	/*************************************************************************//
AnnaBridge	156:ff21514d8981	645	* @brief
AnnaBridge	156:ff21514d8981	646	* Set the width of the DATA1 increment instruction DATA1INC.
AnnaBridge	156:ff21514d8981	647	*
AnnaBridge	156:ff21514d8981	648	* @details
AnnaBridge	156:ff21514d8981	649	* This function sets the width of the DATA1 increment instruction
AnnaBridge	156:ff21514d8981	650	* @ref CRYPTO_CMD_INSTR_DATA1INC.
AnnaBridge	156:ff21514d8981	651	*
AnnaBridge	156:ff21514d8981	652	* @param[in] crypto
AnnaBridge	156:ff21514d8981	653	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	654	*
AnnaBridge	156:ff21514d8981	655	* @param[in] incWidth
AnnaBridge	156:ff21514d8981	656	* incrementation width.
AnnaBridge	156:ff21514d8981	657	******************************************************************************/
AnnaBridge	156:ff21514d8981	658	__STATIC_INLINE void CRYPTO_IncWidthSet(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	659	CRYPTO_IncWidth_TypeDef incWidth)
AnnaBridge	156:ff21514d8981	660	{
AnnaBridge	156:ff21514d8981	661	uint32_t temp = crypto->CTRL & (~_CRYPTO_CTRL_INCWIDTH_MASK);
AnnaBridge	156:ff21514d8981	662	crypto->CTRL = temp \| incWidth;
AnnaBridge	156:ff21514d8981	663	}
AnnaBridge	156:ff21514d8981	664
AnnaBridge	156:ff21514d8981	665	/*************************************************************************//
AnnaBridge	156:ff21514d8981	666	* @brief
AnnaBridge	156:ff21514d8981	667	* Write a 128 bit value into a crypto register.
AnnaBridge	156:ff21514d8981	668	*
AnnaBridge	156:ff21514d8981	669	* @note
AnnaBridge	156:ff21514d8981	670	* This function provide a low-level api for writing to the multi-word
AnnaBridge	156:ff21514d8981	671	* registers in the crypto peripheral. Applications should prefer to use
AnnaBridge	156:ff21514d8981	672	* @ref CRYPTO_DataWrite, @ref CRYPTO_DDataWrite or @ref CRYPTO_QDataWrite
AnnaBridge	156:ff21514d8981	673	* for writing to the DATA, DDATA and QDATA registers.
AnnaBridge	156:ff21514d8981	674	*
AnnaBridge	156:ff21514d8981	675	* @param[in] reg
AnnaBridge	156:ff21514d8981	676	* Pointer to the crypto register.
AnnaBridge	156:ff21514d8981	677	*
AnnaBridge	156:ff21514d8981	678	* @param[in] val
AnnaBridge	156:ff21514d8981	679	* This is a pointer to 4 32 bit integers that contains the 128 bit value
AnnaBridge	156:ff21514d8981	680	* which will be written to the crypto register.
AnnaBridge	156:ff21514d8981	681	******************************************************************************/
AnnaBridge	156:ff21514d8981	682	__STATIC_INLINE void CRYPTO_BurstToCrypto(volatile uint32_t * reg,
AnnaBridge	156:ff21514d8981	683	const uint32_t * val)
AnnaBridge	156:ff21514d8981	684	{
AnnaBridge	156:ff21514d8981	685	/* Load data from memory into local registers. */
AnnaBridge	156:ff21514d8981	686	register uint32_t v0 = val[0];
AnnaBridge	156:ff21514d8981	687	register uint32_t v1 = val[1];
AnnaBridge	156:ff21514d8981	688	register uint32_t v2 = val[2];
AnnaBridge	156:ff21514d8981	689	register uint32_t v3 = val[3];
AnnaBridge	156:ff21514d8981	690	/* Store data to CRYPTO */
AnnaBridge	156:ff21514d8981	691	*reg = v0;
AnnaBridge	156:ff21514d8981	692	*reg = v1;
AnnaBridge	156:ff21514d8981	693	*reg = v2;
AnnaBridge	156:ff21514d8981	694	*reg = v3;
AnnaBridge	156:ff21514d8981	695	}
AnnaBridge	156:ff21514d8981	696
AnnaBridge	156:ff21514d8981	697	/*************************************************************************//
AnnaBridge	156:ff21514d8981	698	* @brief
AnnaBridge	156:ff21514d8981	699	* Read a 128 bit value from a crypto register.
AnnaBridge	156:ff21514d8981	700	*
AnnaBridge	156:ff21514d8981	701	* @note
AnnaBridge	156:ff21514d8981	702	* This function provide a low-level api for reading one of the multi-word
AnnaBridge	156:ff21514d8981	703	* registers in the crypto peripheral. Applications should prefer to use
AnnaBridge	156:ff21514d8981	704	* @ref CRYPTO_DataRead, @ref CRYPTO_DDataRead or @ref CRYPTO_QDataRead
AnnaBridge	156:ff21514d8981	705	* for reading the value of the DATA, DDATA and QDATA registers.
AnnaBridge	156:ff21514d8981	706	*
AnnaBridge	156:ff21514d8981	707	* @param[in] reg
AnnaBridge	156:ff21514d8981	708	* Pointer to the crypto register.
AnnaBridge	156:ff21514d8981	709	*
AnnaBridge	156:ff21514d8981	710	* @param[out] val
AnnaBridge	156:ff21514d8981	711	* This is a pointer to an array that is capable of holding 4 32 bit integers
AnnaBridge	156:ff21514d8981	712	* that will be filled with the 128 bit value from the crypto register.
AnnaBridge	156:ff21514d8981	713	******************************************************************************/
AnnaBridge	156:ff21514d8981	714	__STATIC_INLINE void CRYPTO_BurstFromCrypto(volatile uint32_t * reg, uint32_t * val)
AnnaBridge	156:ff21514d8981	715	{
AnnaBridge	156:ff21514d8981	716	/* Load data from CRYPTO into local registers. */
AnnaBridge	156:ff21514d8981	717	register uint32_t v0 = *reg;
AnnaBridge	156:ff21514d8981	718	register uint32_t v1 = *reg;
AnnaBridge	156:ff21514d8981	719	register uint32_t v2 = *reg;
AnnaBridge	156:ff21514d8981	720	register uint32_t v3 = *reg;
AnnaBridge	156:ff21514d8981	721	/* Store data to memory */
AnnaBridge	156:ff21514d8981	722	val[0] = v0;
AnnaBridge	156:ff21514d8981	723	val[1] = v1;
AnnaBridge	156:ff21514d8981	724	val[2] = v2;
AnnaBridge	156:ff21514d8981	725	val[3] = v3;
AnnaBridge	156:ff21514d8981	726	}
AnnaBridge	156:ff21514d8981	727
AnnaBridge	156:ff21514d8981	728	/*************************************************************************//
AnnaBridge	156:ff21514d8981	729	* @brief
AnnaBridge	156:ff21514d8981	730	* Write 128 bits of data to a DATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	731	*
AnnaBridge	156:ff21514d8981	732	* @details
AnnaBridge	156:ff21514d8981	733	* Write 128 bits of data to a DATAX register in the crypto module. The data
AnnaBridge	156:ff21514d8981	734	* value is typically input to a big integer operation (see crypto
AnnaBridge	156:ff21514d8981	735	* instructions).
AnnaBridge	156:ff21514d8981	736	*
AnnaBridge	156:ff21514d8981	737	* @param[in] dataReg The 128 bit DATA register.
AnnaBridge	156:ff21514d8981	738	* @param[in] val Value of the data to write to the DATA register.
AnnaBridge	156:ff21514d8981	739	******************************************************************************/
AnnaBridge	156:ff21514d8981	740	__STATIC_INLINE void CRYPTO_DataWrite(CRYPTO_DataReg_TypeDef dataReg,
AnnaBridge	156:ff21514d8981	741	const CRYPTO_Data_TypeDef val)
AnnaBridge	156:ff21514d8981	742	{
AnnaBridge	156:ff21514d8981	743	CRYPTO_BurstToCrypto((volatile uint32_t *)dataReg, val);
AnnaBridge	156:ff21514d8981	744	}
AnnaBridge	156:ff21514d8981	745
AnnaBridge	156:ff21514d8981	746	/*************************************************************************//
AnnaBridge	156:ff21514d8981	747	* @brief
AnnaBridge	156:ff21514d8981	748	* Read 128 bits of data from a DATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	749	*
AnnaBridge	156:ff21514d8981	750	* @details
AnnaBridge	156:ff21514d8981	751	* Read 128 bits of data from a DATAX register in the crypto module. The data
AnnaBridge	156:ff21514d8981	752	* value is typically output from a big integer operation (see crypto
AnnaBridge	156:ff21514d8981	753	* instructions)
AnnaBridge	156:ff21514d8981	754	*
AnnaBridge	156:ff21514d8981	755	* @param[in] dataReg The 128 bit DATA register.
AnnaBridge	156:ff21514d8981	756	* @param[out] val Location where to store the value in memory.
AnnaBridge	156:ff21514d8981	757	******************************************************************************/
AnnaBridge	156:ff21514d8981	758	__STATIC_INLINE void CRYPTO_DataRead(CRYPTO_DataReg_TypeDef dataReg,
AnnaBridge	156:ff21514d8981	759	CRYPTO_Data_TypeDef val)
AnnaBridge	156:ff21514d8981	760	{
AnnaBridge	156:ff21514d8981	761	CRYPTO_BurstFromCrypto((volatile uint32_t *)dataReg, val);
AnnaBridge	156:ff21514d8981	762	}
AnnaBridge	156:ff21514d8981	763
AnnaBridge	156:ff21514d8981	764	/*************************************************************************//
AnnaBridge	156:ff21514d8981	765	* @brief
AnnaBridge	156:ff21514d8981	766	* Write 256 bits of data to a DDATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	767	*
AnnaBridge	156:ff21514d8981	768	* @details
AnnaBridge	156:ff21514d8981	769	* Write 256 bits of data into a DDATAX (Double Data) register in the crypto
AnnaBridge	156:ff21514d8981	770	* module. The data value is typically input to a big integer operation (see
AnnaBridge	156:ff21514d8981	771	* crypto instructions).
AnnaBridge	156:ff21514d8981	772	*
AnnaBridge	156:ff21514d8981	773	* @param[in] ddataReg The 256 bit DDATA register.
AnnaBridge	156:ff21514d8981	774	* @param[in] val Value of the data to write to the DDATA register.
AnnaBridge	156:ff21514d8981	775	******************************************************************************/
AnnaBridge	156:ff21514d8981	776	__STATIC_INLINE void CRYPTO_DDataWrite(CRYPTO_DDataReg_TypeDef ddataReg,
AnnaBridge	156:ff21514d8981	777	const CRYPTO_DData_TypeDef val)
AnnaBridge	156:ff21514d8981	778	{
AnnaBridge	156:ff21514d8981	779	CRYPTO_BurstToCrypto((volatile uint32_t *)ddataReg, &val[0]);
AnnaBridge	156:ff21514d8981	780	CRYPTO_BurstToCrypto((volatile uint32_t *)ddataReg, &val[4]);
AnnaBridge	156:ff21514d8981	781	}
AnnaBridge	156:ff21514d8981	782
AnnaBridge	156:ff21514d8981	783	/*************************************************************************//
AnnaBridge	156:ff21514d8981	784	* @brief
AnnaBridge	156:ff21514d8981	785	* Read 256 bits of data from a DDATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	786	*
AnnaBridge	156:ff21514d8981	787	* @details
AnnaBridge	156:ff21514d8981	788	* Read 256 bits of data from a DDATAX (Double Data) register in the crypto
AnnaBridge	156:ff21514d8981	789	* module. The data value is typically output from a big integer operation
AnnaBridge	156:ff21514d8981	790	* (see crypto instructions).
AnnaBridge	156:ff21514d8981	791	*
AnnaBridge	156:ff21514d8981	792	* @param[in] ddataReg The 256 bit DDATA register.
AnnaBridge	156:ff21514d8981	793	* @param[out] val Location where to store the value in memory.
AnnaBridge	156:ff21514d8981	794	******************************************************************************/
AnnaBridge	156:ff21514d8981	795	__STATIC_INLINE void CRYPTO_DDataRead(CRYPTO_DDataReg_TypeDef ddataReg,
AnnaBridge	156:ff21514d8981	796	CRYPTO_DData_TypeDef val)
AnnaBridge	156:ff21514d8981	797	{
AnnaBridge	156:ff21514d8981	798	CRYPTO_BurstFromCrypto((volatile uint32_t *)ddataReg, &val[0]);
AnnaBridge	156:ff21514d8981	799	CRYPTO_BurstFromCrypto((volatile uint32_t *)ddataReg, &val[4]);
AnnaBridge	156:ff21514d8981	800	}
AnnaBridge	156:ff21514d8981	801
AnnaBridge	156:ff21514d8981	802	/*************************************************************************//
AnnaBridge	156:ff21514d8981	803	* @brief
AnnaBridge	156:ff21514d8981	804	* Write 512 bits of data to a QDATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	805	*
AnnaBridge	156:ff21514d8981	806	* @details
AnnaBridge	156:ff21514d8981	807	* Write 512 bits of data into a QDATAX (Quad Data) register in the crypto module
AnnaBridge	156:ff21514d8981	808	* The data value is typically input to a big integer operation (see crypto
AnnaBridge	156:ff21514d8981	809	* instructions).
AnnaBridge	156:ff21514d8981	810	*
AnnaBridge	156:ff21514d8981	811	* @param[in] qdataReg The 512 bits QDATA register.
AnnaBridge	156:ff21514d8981	812	* @param[in] val Value of the data to write to the QDATA register.
AnnaBridge	156:ff21514d8981	813	******************************************************************************/
AnnaBridge	156:ff21514d8981	814	__STATIC_INLINE void CRYPTO_QDataWrite(CRYPTO_QDataReg_TypeDef qdataReg,
AnnaBridge	156:ff21514d8981	815	CRYPTO_QData_TypeDef val)
AnnaBridge	156:ff21514d8981	816	{
AnnaBridge	156:ff21514d8981	817	CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[0]);
AnnaBridge	156:ff21514d8981	818	CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[4]);
AnnaBridge	156:ff21514d8981	819	CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[8]);
AnnaBridge	156:ff21514d8981	820	CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[12]);
AnnaBridge	156:ff21514d8981	821	}
AnnaBridge	156:ff21514d8981	822
AnnaBridge	156:ff21514d8981	823	/*************************************************************************//
AnnaBridge	156:ff21514d8981	824	* @brief
AnnaBridge	156:ff21514d8981	825	* Read 512 bits of data from a QDATAX register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	826	*
AnnaBridge	156:ff21514d8981	827	* @details
AnnaBridge	156:ff21514d8981	828	* Read 512 bits of data from a QDATAX register in the crypto module. The data
AnnaBridge	156:ff21514d8981	829	* value is typically input to a big integer operation (see crypto
AnnaBridge	156:ff21514d8981	830	* instructions).
AnnaBridge	156:ff21514d8981	831	*
AnnaBridge	156:ff21514d8981	832	* @param[in] qdataReg The 512 bits QDATA register.
AnnaBridge	156:ff21514d8981	833	* @param[in] val Value of the data to write to the QDATA register.
AnnaBridge	156:ff21514d8981	834	******************************************************************************/
AnnaBridge	156:ff21514d8981	835	__STATIC_INLINE void CRYPTO_QDataRead(CRYPTO_QDataReg_TypeDef qdataReg,
AnnaBridge	156:ff21514d8981	836	CRYPTO_QData_TypeDef val)
AnnaBridge	156:ff21514d8981	837	{
AnnaBridge	156:ff21514d8981	838	CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[0]);
AnnaBridge	156:ff21514d8981	839	CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[4]);
AnnaBridge	156:ff21514d8981	840	CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[8]);
AnnaBridge	156:ff21514d8981	841	CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[12]);
AnnaBridge	156:ff21514d8981	842	}
AnnaBridge	156:ff21514d8981	843
AnnaBridge	156:ff21514d8981	844	/*************************************************************************//
AnnaBridge	156:ff21514d8981	845	* @brief
AnnaBridge	156:ff21514d8981	846	* Set the key value to be used by the CRYPTO module.
AnnaBridge	156:ff21514d8981	847	*
AnnaBridge	156:ff21514d8981	848	* @details
AnnaBridge	156:ff21514d8981	849	* Write 128 or 256 bit key to the KEYBUF register in the crypto module.
AnnaBridge	156:ff21514d8981	850	*
AnnaBridge	156:ff21514d8981	851	* @param[in] crypto
AnnaBridge	156:ff21514d8981	852	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	853	*
AnnaBridge	156:ff21514d8981	854	* @param[in] val
AnnaBridge	156:ff21514d8981	855	* Value of the data to write to the KEYBUF register.
AnnaBridge	156:ff21514d8981	856	*
AnnaBridge	156:ff21514d8981	857	* @param[in] keyWidth
AnnaBridge	156:ff21514d8981	858	* Key width - 128 or 256 bits
AnnaBridge	156:ff21514d8981	859	******************************************************************************/
AnnaBridge	156:ff21514d8981	860	__STATIC_INLINE void CRYPTO_KeyBufWrite(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	861	CRYPTO_KeyBuf_TypeDef val,
AnnaBridge	156:ff21514d8981	862	CRYPTO_KeyWidth_TypeDef keyWidth)
AnnaBridge	156:ff21514d8981	863	{
AnnaBridge	156:ff21514d8981	864	if (keyWidth == cryptoKey256Bits)
AnnaBridge	156:ff21514d8981	865	{
AnnaBridge	156:ff21514d8981	866	/* Set AES-256 mode */
AnnaBridge	156:ff21514d8981	867	BUS_RegBitWrite(&crypto->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES256);
AnnaBridge	156:ff21514d8981	868	/* Load key in KEYBUF register (= DDATA4) */
AnnaBridge	156:ff21514d8981	869	CRYPTO_DDataWrite(&crypto->DDATA4, (uint32_t *)val);
AnnaBridge	156:ff21514d8981	870	}
AnnaBridge	156:ff21514d8981	871	else
AnnaBridge	156:ff21514d8981	872	{
AnnaBridge	156:ff21514d8981	873	/* Set AES-128 mode */
AnnaBridge	156:ff21514d8981	874	BUS_RegBitWrite(&crypto->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES128);
AnnaBridge	156:ff21514d8981	875	CRYPTO_BurstToCrypto(&crypto->KEYBUF, &val[0]);
AnnaBridge	156:ff21514d8981	876	}
AnnaBridge	156:ff21514d8981	877	}
AnnaBridge	156:ff21514d8981	878
AnnaBridge	156:ff21514d8981	879	void CRYPTO_KeyRead(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	880	CRYPTO_KeyBuf_TypeDef val,
AnnaBridge	156:ff21514d8981	881	CRYPTO_KeyWidth_TypeDef keyWidth);
AnnaBridge	156:ff21514d8981	882
AnnaBridge	156:ff21514d8981	883	/*************************************************************************//
AnnaBridge	156:ff21514d8981	884	* @brief
AnnaBridge	156:ff21514d8981	885	* Quick write 128 bit key to the CRYPTO module.
AnnaBridge	156:ff21514d8981	886	*
AnnaBridge	156:ff21514d8981	887	* @details
AnnaBridge	156:ff21514d8981	888	* Quick write 128 bit key to the KEYBUF register in the CRYPTO module.
AnnaBridge	156:ff21514d8981	889	*
AnnaBridge	156:ff21514d8981	890	* @param[in] crypto
AnnaBridge	156:ff21514d8981	891	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	892	*
AnnaBridge	156:ff21514d8981	893	* @param[in] val
AnnaBridge	156:ff21514d8981	894	* Value of the data to write to the KEYBUF register.
AnnaBridge	156:ff21514d8981	895	******************************************************************************/
AnnaBridge	156:ff21514d8981	896	__STATIC_INLINE void CRYPTO_KeyBuf128Write(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	897	const uint32_t * val)
AnnaBridge	156:ff21514d8981	898	{
AnnaBridge	156:ff21514d8981	899	CRYPTO_BurstToCrypto(&crypto->KEYBUF, val);
AnnaBridge	156:ff21514d8981	900	}
AnnaBridge	156:ff21514d8981	901
AnnaBridge	156:ff21514d8981	902	/*************************************************************************//
AnnaBridge	156:ff21514d8981	903	* @brief
AnnaBridge	156:ff21514d8981	904	* Quick read access of the Carry bit from arithmetic operations.
AnnaBridge	156:ff21514d8981	905	*
AnnaBridge	156:ff21514d8981	906	* @details
AnnaBridge	156:ff21514d8981	907	* This function reads the carry bit of the CRYPTO ALU.
AnnaBridge	156:ff21514d8981	908	*
AnnaBridge	156:ff21514d8981	909	* @param[in] crypto
AnnaBridge	156:ff21514d8981	910	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	911	*
AnnaBridge	156:ff21514d8981	912	* @return
AnnaBridge	156:ff21514d8981	913	* Returns 'true' if carry is 1, and 'false' if carry is 0.
AnnaBridge	156:ff21514d8981	914	******************************************************************************/
AnnaBridge	156:ff21514d8981	915	__STATIC_INLINE bool CRYPTO_CarryIsSet(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	916	{
AnnaBridge	156:ff21514d8981	917	return (crypto->DSTATUS & _CRYPTO_DSTATUS_CARRY_MASK)
AnnaBridge	156:ff21514d8981	918	>> _CRYPTO_DSTATUS_CARRY_SHIFT;
AnnaBridge	156:ff21514d8981	919	}
AnnaBridge	156:ff21514d8981	920
AnnaBridge	156:ff21514d8981	921	/*************************************************************************//
AnnaBridge	156:ff21514d8981	922	* @brief
AnnaBridge	156:ff21514d8981	923	* Quick read access of the 4 LSbits of the DDATA0 register.
AnnaBridge	156:ff21514d8981	924	*
AnnaBridge	156:ff21514d8981	925	* @details
AnnaBridge	156:ff21514d8981	926	* This function quickly retrieves the 4 least significant bits of the
AnnaBridge	156:ff21514d8981	927	* DDATA0 register via the DDATA0LSBS bit field in the DSTATUS register.
AnnaBridge	156:ff21514d8981	928	*
AnnaBridge	156:ff21514d8981	929	* @param[in] crypto
AnnaBridge	156:ff21514d8981	930	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	931	*
AnnaBridge	156:ff21514d8981	932	* @return
AnnaBridge	156:ff21514d8981	933	* Returns the 4 LSbits of DDATA0.
AnnaBridge	156:ff21514d8981	934	******************************************************************************/
AnnaBridge	156:ff21514d8981	935	__STATIC_INLINE uint8_t CRYPTO_DData0_4LSBitsRead(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	936	{
AnnaBridge	156:ff21514d8981	937	return (crypto->DSTATUS & _CRYPTO_DSTATUS_DDATA0LSBS_MASK)
AnnaBridge	156:ff21514d8981	938	>> _CRYPTO_DSTATUS_DDATA0LSBS_SHIFT;
AnnaBridge	156:ff21514d8981	939	}
AnnaBridge	156:ff21514d8981	940
AnnaBridge	156:ff21514d8981	941	/*************************************************************************//
AnnaBridge	156:ff21514d8981	942	* @brief
AnnaBridge	156:ff21514d8981	943	* Read 260 bits from the DDATA0 register.
AnnaBridge	156:ff21514d8981	944	*
AnnaBridge	156:ff21514d8981	945	* @details
AnnaBridge	156:ff21514d8981	946	* This functions reads 260 bits from the DDATA0 register in the CRYPTO
AnnaBridge	156:ff21514d8981	947	* module. The data value is typically output from a big integer operation
AnnaBridge	156:ff21514d8981	948	* (see crypto instructions) when the result width is set to 260 bits by
AnnaBridge	156:ff21514d8981	949	* calling @ref CRYPTO_ResultWidthSet(cryptoResult260Bits);
AnnaBridge	156:ff21514d8981	950	*
AnnaBridge	156:ff21514d8981	951	* @param[in] crypto
AnnaBridge	156:ff21514d8981	952	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	953	*
AnnaBridge	156:ff21514d8981	954	* @param[out] val
AnnaBridge	156:ff21514d8981	955	* Location where to store the value in memory.
AnnaBridge	156:ff21514d8981	956	******************************************************************************/
AnnaBridge	156:ff21514d8981	957	__STATIC_INLINE void CRYPTO_DData0Read260(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	958	CRYPTO_Data260_TypeDef val)
AnnaBridge	156:ff21514d8981	959	{
AnnaBridge	156:ff21514d8981	960	CRYPTO_DDataRead(&crypto->DDATA0, val);
AnnaBridge	156:ff21514d8981	961	val[8] = (crypto->DSTATUS & _CRYPTO_DSTATUS_DDATA0MSBS_MASK)
AnnaBridge	156:ff21514d8981	962	>> _CRYPTO_DSTATUS_DDATA0MSBS_SHIFT;
AnnaBridge	156:ff21514d8981	963	}
AnnaBridge	156:ff21514d8981	964
AnnaBridge	156:ff21514d8981	965	/*************************************************************************//
AnnaBridge	156:ff21514d8981	966	* @brief
AnnaBridge	156:ff21514d8981	967	* Write 260 bits to the DDATA0 register.
AnnaBridge	156:ff21514d8981	968	*
AnnaBridge	156:ff21514d8981	969	* @details
AnnaBridge	156:ff21514d8981	970	* This functions writes 260 bits to the DDATA0 register in the CRYPTO
AnnaBridge	156:ff21514d8981	971	* module. The data value is typically input to a big integer operation
AnnaBridge	156:ff21514d8981	972	* (see crypto instructions) when the result width is set to 260 bits by
AnnaBridge	156:ff21514d8981	973	* calling @ref CRYPTO_ResultWidthSet(cryptoResult260Bits);
AnnaBridge	156:ff21514d8981	974	*
AnnaBridge	156:ff21514d8981	975	* @param[in] crypto
AnnaBridge	156:ff21514d8981	976	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	977	*
AnnaBridge	156:ff21514d8981	978	* @param[out] val
AnnaBridge	156:ff21514d8981	979	* Location where of the value in memory.
AnnaBridge	156:ff21514d8981	980	******************************************************************************/
AnnaBridge	156:ff21514d8981	981	__STATIC_INLINE void CRYPTO_DData0Write260(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	982	const CRYPTO_Data260_TypeDef val)
AnnaBridge	156:ff21514d8981	983	{
AnnaBridge	156:ff21514d8981	984	CRYPTO_DDataWrite(&crypto->DDATA0, val);
AnnaBridge	156:ff21514d8981	985	crypto->DDATA0BYTE32 = val[8] & _CRYPTO_DDATA0BYTE32_DDATA0BYTE32_MASK;
AnnaBridge	156:ff21514d8981	986	}
AnnaBridge	156:ff21514d8981	987
AnnaBridge	156:ff21514d8981	988	/*************************************************************************//
AnnaBridge	156:ff21514d8981	989	* @brief
AnnaBridge	156:ff21514d8981	990	* Quick read the MSbit of the DDATA1 register.
AnnaBridge	156:ff21514d8981	991	*
AnnaBridge	156:ff21514d8981	992	* @details
AnnaBridge	156:ff21514d8981	993	* This function reads the most significant bit (bit 255) of the DDATA1
AnnaBridge	156:ff21514d8981	994	* register via the DDATA1MSB bit field in the DSTATUS register. This can
AnnaBridge	156:ff21514d8981	995	* be used to quickly check the signedness of a big integer resident in the
AnnaBridge	156:ff21514d8981	996	* CRYPTO module.
AnnaBridge	156:ff21514d8981	997	*
AnnaBridge	156:ff21514d8981	998	* @param[in] crypto
AnnaBridge	156:ff21514d8981	999	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1000	*
AnnaBridge	156:ff21514d8981	1001	* @return
AnnaBridge	156:ff21514d8981	1002	* Returns 'true' if MSbit is 1, and 'false' if MSbit is 0.
AnnaBridge	156:ff21514d8981	1003	******************************************************************************/
AnnaBridge	156:ff21514d8981	1004	__STATIC_INLINE bool CRYPTO_DData1_MSBitRead(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1005	{
AnnaBridge	156:ff21514d8981	1006	return (crypto->DSTATUS & _CRYPTO_DSTATUS_DDATA1MSB_MASK)
AnnaBridge	156:ff21514d8981	1007	>> _CRYPTO_DSTATUS_DDATA1MSB_SHIFT;
AnnaBridge	156:ff21514d8981	1008	}
AnnaBridge	156:ff21514d8981	1009
AnnaBridge	156:ff21514d8981	1010	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1011	* @brief
AnnaBridge	156:ff21514d8981	1012	* Load a sequence of instructions to be executed on the current values in
AnnaBridge	156:ff21514d8981	1013	* the data registers.
AnnaBridge	156:ff21514d8981	1014	*
AnnaBridge	156:ff21514d8981	1015	* @details
AnnaBridge	156:ff21514d8981	1016	* This function loads a sequence of instructions to the crypto module. The
AnnaBridge	156:ff21514d8981	1017	* instructions will be executed when the CRYPTO_InstructionSequenceExecute
AnnaBridge	156:ff21514d8981	1018	* function is called. The first END marks the end of the sequence.
AnnaBridge	156:ff21514d8981	1019	*
AnnaBridge	156:ff21514d8981	1020	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1021	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1022	*
AnnaBridge	156:ff21514d8981	1023	* @param[in] instructionSequence
AnnaBridge	156:ff21514d8981	1024	* Instruction sequence to load.
AnnaBridge	156:ff21514d8981	1025	******************************************************************************/
AnnaBridge	156:ff21514d8981	1026	__STATIC_INLINE
AnnaBridge	156:ff21514d8981	1027	void CRYPTO_InstructionSequenceLoad(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1028	const CRYPTO_InstructionSequence_TypeDef instructionSequence)
AnnaBridge	156:ff21514d8981	1029	{
AnnaBridge	156:ff21514d8981	1030	const uint32_t * pas = (const uint32_t *) instructionSequence;
AnnaBridge	156:ff21514d8981	1031
AnnaBridge	156:ff21514d8981	1032	crypto->SEQ0 = pas[0];
AnnaBridge	156:ff21514d8981	1033	crypto->SEQ1 = pas[1];
AnnaBridge	156:ff21514d8981	1034	crypto->SEQ2 = pas[2];
AnnaBridge	156:ff21514d8981	1035	crypto->SEQ3 = pas[3];
AnnaBridge	156:ff21514d8981	1036	crypto->SEQ4 = pas[4];
AnnaBridge	156:ff21514d8981	1037	}
AnnaBridge	156:ff21514d8981	1038
AnnaBridge	156:ff21514d8981	1039	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1040	* @brief
AnnaBridge	156:ff21514d8981	1041	* Execute the current programmed instruction sequence.
AnnaBridge	156:ff21514d8981	1042	*
AnnaBridge	156:ff21514d8981	1043	* @details
AnnaBridge	156:ff21514d8981	1044	* This function starts the execution of the current instruction sequence
AnnaBridge	156:ff21514d8981	1045	* in the CRYPTO module.
AnnaBridge	156:ff21514d8981	1046	*
AnnaBridge	156:ff21514d8981	1047	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1048	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1049	******************************************************************************/
AnnaBridge	156:ff21514d8981	1050	__STATIC_INLINE void CRYPTO_InstructionSequenceExecute(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1051	{
AnnaBridge	156:ff21514d8981	1052	/* Start the command sequence. */
AnnaBridge	156:ff21514d8981	1053	crypto->CMD = CRYPTO_CMD_SEQSTART;
AnnaBridge	156:ff21514d8981	1054	}
AnnaBridge	156:ff21514d8981	1055
AnnaBridge	156:ff21514d8981	1056	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1057	* @brief
AnnaBridge	156:ff21514d8981	1058	* Check whether the execution of an instruction sequence has completed.
AnnaBridge	156:ff21514d8981	1059	*
AnnaBridge	156:ff21514d8981	1060	* @details
AnnaBridge	156:ff21514d8981	1061	* This function checks whether an instruction sequence has completed.
AnnaBridge	156:ff21514d8981	1062	*
AnnaBridge	156:ff21514d8981	1063	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1064	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1065	*
AnnaBridge	156:ff21514d8981	1066	* @return
AnnaBridge	156:ff21514d8981	1067	* Returns 'true' if the instruction sequence is done, and 'false' if not.
AnnaBridge	156:ff21514d8981	1068	******************************************************************************/
AnnaBridge	156:ff21514d8981	1069	__STATIC_INLINE bool CRYPTO_InstructionSequenceDone(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1070	{
AnnaBridge	156:ff21514d8981	1071	/* Return true if operation has completed. */
AnnaBridge	156:ff21514d8981	1072	return !(crypto->STATUS
AnnaBridge	156:ff21514d8981	1073	& (CRYPTO_STATUS_INSTRRUNNING \| CRYPTO_STATUS_SEQRUNNING));
AnnaBridge	156:ff21514d8981	1074	}
AnnaBridge	156:ff21514d8981	1075
AnnaBridge	156:ff21514d8981	1076	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1077	* @brief
AnnaBridge	156:ff21514d8981	1078	* Wait for completion of the current sequence of instructions.
AnnaBridge	156:ff21514d8981	1079	*
AnnaBridge	156:ff21514d8981	1080	* @details
AnnaBridge	156:ff21514d8981	1081	* This function "busy"-waits until the execution of the ongoing instruction
AnnaBridge	156:ff21514d8981	1082	* sequence has completed.
AnnaBridge	156:ff21514d8981	1083	*
AnnaBridge	156:ff21514d8981	1084	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1085	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1086	******************************************************************************/
AnnaBridge	156:ff21514d8981	1087	__STATIC_INLINE void CRYPTO_InstructionSequenceWait(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1088	{
AnnaBridge	156:ff21514d8981	1089	while (!CRYPTO_InstructionSequenceDone(crypto))
AnnaBridge	156:ff21514d8981	1090	;
AnnaBridge	156:ff21514d8981	1091	}
AnnaBridge	156:ff21514d8981	1092
AnnaBridge	156:ff21514d8981	1093	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1094	* @brief
AnnaBridge	156:ff21514d8981	1095	* Wait for completion of the current command.
AnnaBridge	156:ff21514d8981	1096	*
AnnaBridge	156:ff21514d8981	1097	* @details
AnnaBridge	156:ff21514d8981	1098	* This function "busy"-waits until the execution of the ongoing instruction
AnnaBridge	156:ff21514d8981	1099	* has completed.
AnnaBridge	156:ff21514d8981	1100	*
AnnaBridge	156:ff21514d8981	1101	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1102	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1103	******************************************************************************/
AnnaBridge	156:ff21514d8981	1104	__STATIC_INLINE void CRYPTO_InstructionWait(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1105	{
AnnaBridge	156:ff21514d8981	1106	/* Wait for completion */
AnnaBridge	156:ff21514d8981	1107	while (!(crypto->IF & CRYPTO_IF_INSTRDONE))
AnnaBridge	156:ff21514d8981	1108	;
AnnaBridge	156:ff21514d8981	1109	crypto->IFC = CRYPTO_IF_INSTRDONE;
AnnaBridge	156:ff21514d8981	1110	}
AnnaBridge	156:ff21514d8981	1111
AnnaBridge	156:ff21514d8981	1112	void CRYPTO_SHA_1(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1113	const uint8_t *msg,
AnnaBridge	156:ff21514d8981	1114	uint64_t msgLen,
AnnaBridge	156:ff21514d8981	1115	CRYPTO_SHA1_Digest_TypeDef digest);
AnnaBridge	156:ff21514d8981	1116
AnnaBridge	156:ff21514d8981	1117	void CRYPTO_SHA_256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1118	const uint8_t *msg,
AnnaBridge	156:ff21514d8981	1119	uint64_t msgLen,
AnnaBridge	156:ff21514d8981	1120	CRYPTO_SHA256_Digest_TypeDef digest);
AnnaBridge	156:ff21514d8981	1121
AnnaBridge	156:ff21514d8981	1122	void CRYPTO_Mul(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1123	uint32_t * A, int aSize,
AnnaBridge	156:ff21514d8981	1124	uint32_t * B, int bSize,
AnnaBridge	156:ff21514d8981	1125	uint32_t * R, int rSize);
AnnaBridge	156:ff21514d8981	1126
AnnaBridge	156:ff21514d8981	1127	void CRYPTO_AES_CBC128(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1128	uint8_t * out,
AnnaBridge	156:ff21514d8981	1129	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1130	unsigned int len,
AnnaBridge	156:ff21514d8981	1131	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1132	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1133	bool encrypt);
AnnaBridge	156:ff21514d8981	1134
AnnaBridge	156:ff21514d8981	1135	void CRYPTO_AES_CBC256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1136	uint8_t * out,
AnnaBridge	156:ff21514d8981	1137	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1138	unsigned int len,
AnnaBridge	156:ff21514d8981	1139	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1140	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1141	bool encrypt);
AnnaBridge	156:ff21514d8981	1142
AnnaBridge	156:ff21514d8981	1143	void CRYPTO_AES_CFB128(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1144	uint8_t * out,
AnnaBridge	156:ff21514d8981	1145	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1146	unsigned int len,
AnnaBridge	156:ff21514d8981	1147	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1148	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1149	bool encrypt);
AnnaBridge	156:ff21514d8981	1150
AnnaBridge	156:ff21514d8981	1151	void CRYPTO_AES_CFB256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1152	uint8_t * out,
AnnaBridge	156:ff21514d8981	1153	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1154	unsigned int len,
AnnaBridge	156:ff21514d8981	1155	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1156	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1157	bool encrypt);
AnnaBridge	156:ff21514d8981	1158
AnnaBridge	156:ff21514d8981	1159	void CRYPTO_AES_CTR128(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1160	uint8_t * out,
AnnaBridge	156:ff21514d8981	1161	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1162	unsigned int len,
AnnaBridge	156:ff21514d8981	1163	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1164	uint8_t * ctr,
AnnaBridge	156:ff21514d8981	1165	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
AnnaBridge	156:ff21514d8981	1166
AnnaBridge	156:ff21514d8981	1167	void CRYPTO_AES_CTR256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1168	uint8_t * out,
AnnaBridge	156:ff21514d8981	1169	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1170	unsigned int len,
AnnaBridge	156:ff21514d8981	1171	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1172	uint8_t * ctr,
AnnaBridge	156:ff21514d8981	1173	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
AnnaBridge	156:ff21514d8981	1174
AnnaBridge	156:ff21514d8981	1175	void CRYPTO_AES_CTRUpdate32Bit(uint8_t * ctr);
AnnaBridge	156:ff21514d8981	1176	void CRYPTO_AES_DecryptKey128(CRYPTO_TypeDef crypto, uint8_t out, const uint8_t * in);
AnnaBridge	156:ff21514d8981	1177	void CRYPTO_AES_DecryptKey256(CRYPTO_TypeDef crypto, uint8_t out, const uint8_t * in);
AnnaBridge	156:ff21514d8981	1178
AnnaBridge	156:ff21514d8981	1179	void CRYPTO_AES_ECB128(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1180	uint8_t * out,
AnnaBridge	156:ff21514d8981	1181	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1182	unsigned int len,
AnnaBridge	156:ff21514d8981	1183	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1184	bool encrypt);
AnnaBridge	156:ff21514d8981	1185
AnnaBridge	156:ff21514d8981	1186	void CRYPTO_AES_ECB256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1187	uint8_t * out,
AnnaBridge	156:ff21514d8981	1188	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1189	unsigned int len,
AnnaBridge	156:ff21514d8981	1190	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1191	bool encrypt);
AnnaBridge	156:ff21514d8981	1192
AnnaBridge	156:ff21514d8981	1193	void CRYPTO_AES_OFB128(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1194	uint8_t * out,
AnnaBridge	156:ff21514d8981	1195	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1196	unsigned int len,
AnnaBridge	156:ff21514d8981	1197	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1198	const uint8_t * iv);
AnnaBridge	156:ff21514d8981	1199
AnnaBridge	156:ff21514d8981	1200	void CRYPTO_AES_OFB256(CRYPTO_TypeDef *crypto,
AnnaBridge	156:ff21514d8981	1201	uint8_t * out,
AnnaBridge	156:ff21514d8981	1202	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1203	unsigned int len,
AnnaBridge	156:ff21514d8981	1204	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1205	const uint8_t * iv);
AnnaBridge	156:ff21514d8981	1206
AnnaBridge	156:ff21514d8981	1207	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1208	* @brief
AnnaBridge	156:ff21514d8981	1209	* Clear one or more pending CRYPTO interrupts.
AnnaBridge	156:ff21514d8981	1210	*
AnnaBridge	156:ff21514d8981	1211	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1212	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1213	*
AnnaBridge	156:ff21514d8981	1214	* @param[in] flags
AnnaBridge	156:ff21514d8981	1215	* Pending CRYPTO interrupt source to clear. Use a bitwise logic OR combination of
AnnaBridge	156:ff21514d8981	1216	* valid interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).
AnnaBridge	156:ff21514d8981	1217	******************************************************************************/
AnnaBridge	156:ff21514d8981	1218	__STATIC_INLINE void CRYPTO_IntClear(CRYPTO_TypeDef *crypto, uint32_t flags)
AnnaBridge	156:ff21514d8981	1219	{
AnnaBridge	156:ff21514d8981	1220	crypto->IFC = flags;
AnnaBridge	156:ff21514d8981	1221	}
AnnaBridge	156:ff21514d8981	1222
AnnaBridge	156:ff21514d8981	1223	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1224	* @brief
AnnaBridge	156:ff21514d8981	1225	* Disable one or more CRYPTO interrupts.
AnnaBridge	156:ff21514d8981	1226	*
AnnaBridge	156:ff21514d8981	1227	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1228	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1229	*
AnnaBridge	156:ff21514d8981	1230	* @param[in] flags
AnnaBridge	156:ff21514d8981	1231	* CRYPTO interrupt sources to disable. Use a bitwise logic OR combination of
AnnaBridge	156:ff21514d8981	1232	* valid interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).
AnnaBridge	156:ff21514d8981	1233	******************************************************************************/
AnnaBridge	156:ff21514d8981	1234	__STATIC_INLINE void CRYPTO_IntDisable(CRYPTO_TypeDef *crypto, uint32_t flags)
AnnaBridge	156:ff21514d8981	1235	{
AnnaBridge	156:ff21514d8981	1236	crypto->IEN &= ~(flags);
AnnaBridge	156:ff21514d8981	1237	}
AnnaBridge	156:ff21514d8981	1238
AnnaBridge	156:ff21514d8981	1239	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1240	* @brief
AnnaBridge	156:ff21514d8981	1241	* Enable one or more CRYPTO interrupts.
AnnaBridge	156:ff21514d8981	1242	*
AnnaBridge	156:ff21514d8981	1243	* @note
AnnaBridge	156:ff21514d8981	1244	* Depending on the use, a pending interrupt may already be set prior to
AnnaBridge	156:ff21514d8981	1245	* enabling the interrupt. Consider using CRYPTO_IntClear() prior to enabling
AnnaBridge	156:ff21514d8981	1246	* if such a pending interrupt should be ignored.
AnnaBridge	156:ff21514d8981	1247	*
AnnaBridge	156:ff21514d8981	1248	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1249	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1250	*
AnnaBridge	156:ff21514d8981	1251	* @param[in] flags
AnnaBridge	156:ff21514d8981	1252	* CRYPTO interrupt sources to enable. Use a bitwise logic OR combination of
AnnaBridge	156:ff21514d8981	1253	* valid interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).
AnnaBridge	156:ff21514d8981	1254	******************************************************************************/
AnnaBridge	156:ff21514d8981	1255	__STATIC_INLINE void CRYPTO_IntEnable(CRYPTO_TypeDef *crypto, uint32_t flags)
AnnaBridge	156:ff21514d8981	1256	{
AnnaBridge	156:ff21514d8981	1257	crypto->IEN \|= flags;
AnnaBridge	156:ff21514d8981	1258	}
AnnaBridge	156:ff21514d8981	1259
AnnaBridge	156:ff21514d8981	1260	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1261	* @brief
AnnaBridge	156:ff21514d8981	1262	* Get pending CRYPTO interrupt flags.
AnnaBridge	156:ff21514d8981	1263	*
AnnaBridge	156:ff21514d8981	1264	* @note
AnnaBridge	156:ff21514d8981	1265	* The event bits are not cleared by the use of this function.
AnnaBridge	156:ff21514d8981	1266	*
AnnaBridge	156:ff21514d8981	1267	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1268	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1269	*
AnnaBridge	156:ff21514d8981	1270	* @return
AnnaBridge	156:ff21514d8981	1271	* CRYPTO interrupt sources pending. A bitwise logic OR combination of valid
AnnaBridge	156:ff21514d8981	1272	* interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).
AnnaBridge	156:ff21514d8981	1273	******************************************************************************/
AnnaBridge	156:ff21514d8981	1274	__STATIC_INLINE uint32_t CRYPTO_IntGet(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1275	{
AnnaBridge	156:ff21514d8981	1276	return crypto->IF;
AnnaBridge	156:ff21514d8981	1277	}
AnnaBridge	156:ff21514d8981	1278
AnnaBridge	156:ff21514d8981	1279	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1280	* @brief
AnnaBridge	156:ff21514d8981	1281	* Get enabled and pending CRYPTO interrupt flags.
AnnaBridge	156:ff21514d8981	1282	* Useful for handling more interrupt sources in the same interrupt handler.
AnnaBridge	156:ff21514d8981	1283	*
AnnaBridge	156:ff21514d8981	1284	* @note
AnnaBridge	156:ff21514d8981	1285	* Interrupt flags are not cleared by the use of this function.
AnnaBridge	156:ff21514d8981	1286	*
AnnaBridge	156:ff21514d8981	1287	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1288	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1289	*
AnnaBridge	156:ff21514d8981	1290	* @return
AnnaBridge	156:ff21514d8981	1291	* Pending and enabled CRYPTO interrupt sources
AnnaBridge	156:ff21514d8981	1292	* The return value is the bitwise AND of
AnnaBridge	156:ff21514d8981	1293	* - the enabled interrupt sources in CRYPTO_IEN and
AnnaBridge	156:ff21514d8981	1294	* - the pending interrupt flags CRYPTO_IF
AnnaBridge	156:ff21514d8981	1295	******************************************************************************/
AnnaBridge	156:ff21514d8981	1296	__STATIC_INLINE uint32_t CRYPTO_IntGetEnabled(CRYPTO_TypeDef *crypto)
AnnaBridge	156:ff21514d8981	1297	{
AnnaBridge	156:ff21514d8981	1298	uint32_t tmp;
AnnaBridge	156:ff21514d8981	1299
AnnaBridge	156:ff21514d8981	1300	/* Store IEN in temporary variable in order to define explicit order
AnnaBridge	156:ff21514d8981	1301	* of volatile accesses. */
AnnaBridge	156:ff21514d8981	1302	tmp = crypto->IEN;
AnnaBridge	156:ff21514d8981	1303
AnnaBridge	156:ff21514d8981	1304	/* Bitwise AND of pending and enabled interrupts */
AnnaBridge	156:ff21514d8981	1305	return crypto->IF & tmp;
AnnaBridge	156:ff21514d8981	1306	}
AnnaBridge	156:ff21514d8981	1307
AnnaBridge	156:ff21514d8981	1308	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1309	* @brief
AnnaBridge	156:ff21514d8981	1310	* Set one or more pending CRYPTO interrupts from SW.
AnnaBridge	156:ff21514d8981	1311	*
AnnaBridge	156:ff21514d8981	1312	* @param[in] crypto
AnnaBridge	156:ff21514d8981	1313	* Pointer to CRYPTO peripheral register block.
AnnaBridge	156:ff21514d8981	1314	*
AnnaBridge	156:ff21514d8981	1315	* @param[in] flags
AnnaBridge	156:ff21514d8981	1316	* CRYPTO interrupt sources to set to pending. Use a bitwise logic OR combination
AnnaBridge	156:ff21514d8981	1317	* of valid interrupt flags for the CRYPTO module (CRYPTO_IF_nnn).
AnnaBridge	156:ff21514d8981	1318	******************************************************************************/
AnnaBridge	156:ff21514d8981	1319	__STATIC_INLINE void CRYPTO_IntSet(CRYPTO_TypeDef *crypto, uint32_t flags)
AnnaBridge	156:ff21514d8981	1320	{
AnnaBridge	156:ff21514d8981	1321	crypto->IFS = flags;
AnnaBridge	156:ff21514d8981	1322	}
AnnaBridge	156:ff21514d8981	1323
AnnaBridge	156:ff21514d8981	1324	/*******************************************************************************
AnnaBridge	156:ff21514d8981	1325	*** Static inline wrappers for CRYPTO AES functions in order to ***
AnnaBridge	156:ff21514d8981	1326	*** preserve backwards compatibility with AES module API functions. ***
AnnaBridge	156:ff21514d8981	1327	******************************************************************************/
AnnaBridge	156:ff21514d8981	1328
AnnaBridge	156:ff21514d8981	1329	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1330	* @brief
AnnaBridge	156:ff21514d8981	1331	* AES Cipher-block chaining (CBC) cipher mode encryption/decryption,
AnnaBridge	156:ff21514d8981	1332	* 128 bit key.
AnnaBridge	156:ff21514d8981	1333	*
AnnaBridge	156:ff21514d8981	1334	* @deprecated
AnnaBridge	156:ff21514d8981	1335	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1336	* @ref CRYPTO_AES_CBC128 instead.
AnnaBridge	156:ff21514d8981	1337	******************************************************************************/
AnnaBridge	156:ff21514d8981	1338	__STATIC_INLINE void AES_CBC128(uint8_t * out,
AnnaBridge	156:ff21514d8981	1339	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1340	unsigned int len,
AnnaBridge	156:ff21514d8981	1341	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1342	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1343	bool encrypt)
AnnaBridge	156:ff21514d8981	1344	{
AnnaBridge	156:ff21514d8981	1345	CRYPTO_AES_CBC128(CRYPTO, out, in, len, key, iv, encrypt);
AnnaBridge	156:ff21514d8981	1346	}
AnnaBridge	156:ff21514d8981	1347
AnnaBridge	156:ff21514d8981	1348	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1349	* @brief
AnnaBridge	156:ff21514d8981	1350	* AES Cipher-block chaining (CBC) cipher mode encryption/decryption, 256 bit
AnnaBridge	156:ff21514d8981	1351	* key.
AnnaBridge	156:ff21514d8981	1352	*
AnnaBridge	156:ff21514d8981	1353	* @deprecated
AnnaBridge	156:ff21514d8981	1354	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1355	* @ref CRYPTO_AES_CBC256 instead.
AnnaBridge	156:ff21514d8981	1356	******************************************************************************/
AnnaBridge	156:ff21514d8981	1357	__STATIC_INLINE void AES_CBC256(uint8_t * out,
AnnaBridge	156:ff21514d8981	1358	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1359	unsigned int len,
AnnaBridge	156:ff21514d8981	1360	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1361	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1362	bool encrypt)
AnnaBridge	156:ff21514d8981	1363	{
AnnaBridge	156:ff21514d8981	1364	CRYPTO_AES_CBC256(CRYPTO, out, in, len, key, iv, encrypt);
AnnaBridge	156:ff21514d8981	1365	}
AnnaBridge	156:ff21514d8981	1366
AnnaBridge	156:ff21514d8981	1367	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1368	* @brief
AnnaBridge	156:ff21514d8981	1369	* AES Cipher feedback (CFB) cipher mode encryption/decryption, 128 bit key.
AnnaBridge	156:ff21514d8981	1370	*
AnnaBridge	156:ff21514d8981	1371	* @deprecated
AnnaBridge	156:ff21514d8981	1372	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1373	* @ref CRYPTO_AES_CFB128 instead.
AnnaBridge	156:ff21514d8981	1374	******************************************************************************/
AnnaBridge	156:ff21514d8981	1375	__STATIC_INLINE void AES_CFB128(uint8_t * out,
AnnaBridge	156:ff21514d8981	1376	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1377	unsigned int len,
AnnaBridge	156:ff21514d8981	1378	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1379	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1380	bool encrypt)
AnnaBridge	156:ff21514d8981	1381	{
AnnaBridge	156:ff21514d8981	1382	CRYPTO_AES_CFB128(CRYPTO, out, in, len, key, iv, encrypt);
AnnaBridge	156:ff21514d8981	1383	}
AnnaBridge	156:ff21514d8981	1384
AnnaBridge	156:ff21514d8981	1385	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1386	* @brief
AnnaBridge	156:ff21514d8981	1387	* AES Cipher feedback (CFB) cipher mode encryption/decryption, 256 bit key.
AnnaBridge	156:ff21514d8981	1388	*
AnnaBridge	156:ff21514d8981	1389	* @deprecated
AnnaBridge	156:ff21514d8981	1390	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1391	* @ref CRYPTO_AES_CFB256 instead.
AnnaBridge	156:ff21514d8981	1392	******************************************************************************/
AnnaBridge	156:ff21514d8981	1393	__STATIC_INLINE void AES_CFB256(uint8_t * out,
AnnaBridge	156:ff21514d8981	1394	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1395	unsigned int len,
AnnaBridge	156:ff21514d8981	1396	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1397	const uint8_t * iv,
AnnaBridge	156:ff21514d8981	1398	bool encrypt)
AnnaBridge	156:ff21514d8981	1399	{
AnnaBridge	156:ff21514d8981	1400	CRYPTO_AES_CFB256(CRYPTO, out, in, len, key, iv, encrypt);
AnnaBridge	156:ff21514d8981	1401	}
AnnaBridge	156:ff21514d8981	1402
AnnaBridge	156:ff21514d8981	1403	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1404	* @brief
AnnaBridge	156:ff21514d8981	1405	* AES Counter (CTR) cipher mode encryption/decryption, 128 bit key.
AnnaBridge	156:ff21514d8981	1406	*
AnnaBridge	156:ff21514d8981	1407	* @deprecated
AnnaBridge	156:ff21514d8981	1408	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1409	* @ref CRYPTO_AES_CTR128 instead.
AnnaBridge	156:ff21514d8981	1410	******************************************************************************/
AnnaBridge	156:ff21514d8981	1411	__STATIC_INLINE void AES_CTR128(uint8_t * out,
AnnaBridge	156:ff21514d8981	1412	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1413	unsigned int len,
AnnaBridge	156:ff21514d8981	1414	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1415	uint8_t * ctr,
AnnaBridge	156:ff21514d8981	1416	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
AnnaBridge	156:ff21514d8981	1417	{
AnnaBridge	156:ff21514d8981	1418	CRYPTO_AES_CTR128(CRYPTO, out, in, len, key, ctr, ctrFunc);
AnnaBridge	156:ff21514d8981	1419	}
AnnaBridge	156:ff21514d8981	1420
AnnaBridge	156:ff21514d8981	1421	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1422	* @brief
AnnaBridge	156:ff21514d8981	1423	* AES Counter (CTR) cipher mode encryption/decryption, 256 bit key.
AnnaBridge	156:ff21514d8981	1424	*
AnnaBridge	156:ff21514d8981	1425	* @deprecated
AnnaBridge	156:ff21514d8981	1426	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1427	* @ref CRYPTO_AES_CTR256 instead.
AnnaBridge	156:ff21514d8981	1428	******************************************************************************/
AnnaBridge	156:ff21514d8981	1429	__STATIC_INLINE void AES_CTR256(uint8_t * out,
AnnaBridge	156:ff21514d8981	1430	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1431	unsigned int len,
AnnaBridge	156:ff21514d8981	1432	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1433	uint8_t * ctr,
AnnaBridge	156:ff21514d8981	1434	CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
AnnaBridge	156:ff21514d8981	1435	{
AnnaBridge	156:ff21514d8981	1436	CRYPTO_AES_CTR256(CRYPTO, out, in, len, key, ctr, ctrFunc);
AnnaBridge	156:ff21514d8981	1437	}
AnnaBridge	156:ff21514d8981	1438
AnnaBridge	156:ff21514d8981	1439	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1440	* @brief
AnnaBridge	156:ff21514d8981	1441	* Update last 32 bits of 128 bit counter, by incrementing with 1.
AnnaBridge	156:ff21514d8981	1442	*
AnnaBridge	156:ff21514d8981	1443	* @deprecated
AnnaBridge	156:ff21514d8981	1444	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1445	* @ref CRYPTO_AES_CTRUpdate32Bit instead.
AnnaBridge	156:ff21514d8981	1446	******************************************************************************/
AnnaBridge	156:ff21514d8981	1447	__STATIC_INLINE void AES_CTRUpdate32Bit(uint8_t * ctr)
AnnaBridge	156:ff21514d8981	1448	{
AnnaBridge	156:ff21514d8981	1449	CRYPTO_AES_CTRUpdate32Bit(ctr);
AnnaBridge	156:ff21514d8981	1450	}
AnnaBridge	156:ff21514d8981	1451
AnnaBridge	156:ff21514d8981	1452	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1453	* @brief
AnnaBridge	156:ff21514d8981	1454	* Generate 128 bit AES decryption key from 128 bit encryption key. The
AnnaBridge	156:ff21514d8981	1455	* decryption key is used for some cipher modes when decrypting.
AnnaBridge	156:ff21514d8981	1456	*
AnnaBridge	156:ff21514d8981	1457	* @deprecated
AnnaBridge	156:ff21514d8981	1458	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1459	* @ref CRYPTO_AES_DecryptKey128 instead.
AnnaBridge	156:ff21514d8981	1460	******************************************************************************/
AnnaBridge	156:ff21514d8981	1461	__STATIC_INLINE void AES_DecryptKey128(uint8_t * out, const uint8_t * in)
AnnaBridge	156:ff21514d8981	1462	{
AnnaBridge	156:ff21514d8981	1463	CRYPTO_AES_DecryptKey128(CRYPTO, out, in);
AnnaBridge	156:ff21514d8981	1464	}
AnnaBridge	156:ff21514d8981	1465
AnnaBridge	156:ff21514d8981	1466	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1467	* @brief
AnnaBridge	156:ff21514d8981	1468	* Generate 256 bit AES decryption key from 256 bit encryption key. The
AnnaBridge	156:ff21514d8981	1469	* decryption key is used for some cipher modes when decrypting.
AnnaBridge	156:ff21514d8981	1470	*
AnnaBridge	156:ff21514d8981	1471	* @deprecated
AnnaBridge	156:ff21514d8981	1472	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1473	* @ref CRYPTO_AES_DecryptKey256 instead.
AnnaBridge	156:ff21514d8981	1474	******************************************************************************/
AnnaBridge	156:ff21514d8981	1475	__STATIC_INLINE void AES_DecryptKey256(uint8_t * out, const uint8_t * in)
AnnaBridge	156:ff21514d8981	1476	{
AnnaBridge	156:ff21514d8981	1477	CRYPTO_AES_DecryptKey256(CRYPTO, out, in);
AnnaBridge	156:ff21514d8981	1478	}
AnnaBridge	156:ff21514d8981	1479
AnnaBridge	156:ff21514d8981	1480	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1481	* @brief
AnnaBridge	156:ff21514d8981	1482	* AES Electronic Codebook (ECB) cipher mode encryption/decryption,
AnnaBridge	156:ff21514d8981	1483	* 128 bit key.
AnnaBridge	156:ff21514d8981	1484	*
AnnaBridge	156:ff21514d8981	1485	* @deprecated
AnnaBridge	156:ff21514d8981	1486	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1487	* @ref CRYPTO_AES_ECB128 instead.
AnnaBridge	156:ff21514d8981	1488	******************************************************************************/
AnnaBridge	156:ff21514d8981	1489	__STATIC_INLINE void AES_ECB128(uint8_t * out,
AnnaBridge	156:ff21514d8981	1490	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1491	unsigned int len,
AnnaBridge	156:ff21514d8981	1492	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1493	bool encrypt)
AnnaBridge	156:ff21514d8981	1494	{
AnnaBridge	156:ff21514d8981	1495	CRYPTO_AES_ECB128(CRYPTO, out, in, len, key, encrypt);
AnnaBridge	156:ff21514d8981	1496	}
AnnaBridge	156:ff21514d8981	1497
AnnaBridge	156:ff21514d8981	1498	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1499	* @brief
AnnaBridge	156:ff21514d8981	1500	* AES Electronic Codebook (ECB) cipher mode encryption/decryption,
AnnaBridge	156:ff21514d8981	1501	* 256 bit key.
AnnaBridge	156:ff21514d8981	1502	*
AnnaBridge	156:ff21514d8981	1503	* @deprecated
AnnaBridge	156:ff21514d8981	1504	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1505	* @ref CRYPTO_AES_ECB256 instead.
AnnaBridge	156:ff21514d8981	1506	******************************************************************************/
AnnaBridge	156:ff21514d8981	1507	__STATIC_INLINE void AES_ECB256(uint8_t * out,
AnnaBridge	156:ff21514d8981	1508	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1509	unsigned int len,
AnnaBridge	156:ff21514d8981	1510	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1511	bool encrypt)
AnnaBridge	156:ff21514d8981	1512	{
AnnaBridge	156:ff21514d8981	1513	CRYPTO_AES_ECB256(CRYPTO, out, in, len, key, encrypt);
AnnaBridge	156:ff21514d8981	1514	}
AnnaBridge	156:ff21514d8981	1515
AnnaBridge	156:ff21514d8981	1516	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1517	* @brief
AnnaBridge	156:ff21514d8981	1518	* AES Output feedback (OFB) cipher mode encryption/decryption, 128 bit key.
AnnaBridge	156:ff21514d8981	1519	*
AnnaBridge	156:ff21514d8981	1520	* @deprecated
AnnaBridge	156:ff21514d8981	1521	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1522	* @ref CRYPTO_AES_OFB128 instead.
AnnaBridge	156:ff21514d8981	1523	******************************************************************************/
AnnaBridge	156:ff21514d8981	1524	__STATIC_INLINE void AES_OFB128(uint8_t * out,
AnnaBridge	156:ff21514d8981	1525	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1526	unsigned int len,
AnnaBridge	156:ff21514d8981	1527	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1528	const uint8_t * iv)
AnnaBridge	156:ff21514d8981	1529	{
AnnaBridge	156:ff21514d8981	1530	CRYPTO_AES_OFB128(CRYPTO, out, in, len, key, iv);
AnnaBridge	156:ff21514d8981	1531	}
AnnaBridge	156:ff21514d8981	1532
AnnaBridge	156:ff21514d8981	1533	/*************************************************************************//
AnnaBridge	156:ff21514d8981	1534	* @brief
AnnaBridge	156:ff21514d8981	1535	* AES Output feedback (OFB) cipher mode encryption/decryption, 256 bit key.
AnnaBridge	156:ff21514d8981	1536	*
AnnaBridge	156:ff21514d8981	1537	* @deprecated
AnnaBridge	156:ff21514d8981	1538	* This function is present to preserve backwards compatibility. Use
AnnaBridge	156:ff21514d8981	1539	* @ref CRYPTO_AES_OFB256 instead.
AnnaBridge	156:ff21514d8981	1540	******************************************************************************/
AnnaBridge	156:ff21514d8981	1541	__STATIC_INLINE void AES_OFB256(uint8_t * out,
AnnaBridge	156:ff21514d8981	1542	const uint8_t * in,
AnnaBridge	156:ff21514d8981	1543	unsigned int len,
AnnaBridge	156:ff21514d8981	1544	const uint8_t * key,
AnnaBridge	156:ff21514d8981	1545	const uint8_t * iv)
AnnaBridge	156:ff21514d8981	1546	{
AnnaBridge	156:ff21514d8981	1547	CRYPTO_AES_OFB256(CRYPTO, out, in, len, key, iv);
AnnaBridge	156:ff21514d8981	1548	}
AnnaBridge	156:ff21514d8981	1549
AnnaBridge	156:ff21514d8981	1550	#ifdef __cplusplus
AnnaBridge	156:ff21514d8981	1551	}
AnnaBridge	156:ff21514d8981	1552	#endif
AnnaBridge	156:ff21514d8981	1553
AnnaBridge	156:ff21514d8981	1554	/** @} (end addtogroup CRYPTO) */
AnnaBridge	156:ff21514d8981	1555	/** @} (end addtogroup emlib) */
AnnaBridge	156:ff21514d8981	1556
AnnaBridge	156:ff21514d8981	1557	#endif /* defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0) */
AnnaBridge	156:ff21514d8981	1558
AnnaBridge	156:ff21514d8981	1559	#endif /* EM_CRYPTO_H */