EFM32 Wonder Gecko Software Documentation  efm32wg-doc-4.2.1
em_crypto.h
Go to the documentation of this file.
1 /***************************************************************************/
32 #ifndef __SILICON_LABS_EM_CRYPTO_H__
33 #define __SILICON_LABS_EM_CRYPTO_H__
34 
35 #include "em_device.h"
36 
37 #if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0)
38 
39 #include "em_bus.h"
40 #include <stdbool.h>
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 /***************************************************************************/
51 /***************************************************************************/
56  /*******************************************************************************
57  ****************************** DEFINES ***********************************
58  ******************************************************************************/
59 
62 #define CRYPTO_DATA_SIZE_IN_BITS (128)
63 #define CRYPTO_DATA_SIZE_IN_BYTES (CRYPTO_DATA_SIZE_IN_BITS/8)
64 #define CRYPTO_DATA_SIZE_IN_32BIT_WORDS (CRYPTO_DATA_SIZE_IN_BYTES/sizeof(uint32_t))
65 
66 #define CRYPTO_KEYBUF_SIZE_IN_BITS (256)
67 #define CRYPTO_KEYBUF_SIZE_IN_BYTES (CRYPTO_DDATA_SIZE_IN_BITS/8)
68 #define CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS (CRYPTO_DDATA_SIZE_IN_BYTES/sizeof(uint32_t))
69 
70 #define CRYPTO_DDATA_SIZE_IN_BITS (256)
71 #define CRYPTO_DDATA_SIZE_IN_BYTES (CRYPTO_DDATA_SIZE_IN_BITS/8)
72 #define CRYPTO_DDATA_SIZE_IN_32BIT_WORDS (CRYPTO_DDATA_SIZE_IN_BYTES/sizeof(uint32_t))
73 
74 #define CRYPTO_QDATA_SIZE_IN_BITS (512)
75 #define CRYPTO_QDATA_SIZE_IN_BYTES (CRYPTO_QDATA_SIZE_IN_BITS/8)
76 #define CRYPTO_QDATA_SIZE_IN_32BIT_WORDS (CRYPTO_QDATA_SIZE_IN_BYTES/sizeof(uint32_t))
77 
78 #define CRYPTO_DATA260_SIZE_IN_32BIT_WORDS (9)
79 
81 #define CRYPTO_SHA1_DIGEST_SIZE_IN_BITS (160)
82 #define CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA1_DIGEST_SIZE_IN_BITS/8)
83 
85 #define CRYPTO_SHA256_DIGEST_SIZE_IN_BITS (256)
86 #define CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA256_DIGEST_SIZE_IN_BITS/8)
87 
91 #define CRYPTO_DDATA0_260_BITS_READ(bigint260) CRYPTO_DData0Read260(bigint260)
92 #define CRYPTO_DDATA0_260_BITS_WRITE(bigint260) CRYPTO_DData0Write260(bigint260)
93 
101 #define CRYPTO_SEQ_LOAD_1(a1) { \
102  CRYPTO->SEQ0 = a1 | (CRYPTO_CMD_INSTR_END<<8);}
103 #define CRYPTO_SEQ_LOAD_2(a1, a2) { \
104  CRYPTO->SEQ0 = a1 | (a2<<8) | (CRYPTO_CMD_INSTR_END<<16);}
105 #define CRYPTO_SEQ_LOAD_3(a1, a2, a3) { \
106  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (CRYPTO_CMD_INSTR_END<<24);}
107 #define CRYPTO_SEQ_LOAD_4(a1, a2, a3, a4) { \
108  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
109  CRYPTO->SEQ1 = CRYPTO_CMD_INSTR_END;}
110 #define CRYPTO_SEQ_LOAD_5(a1, a2, a3, a4, a5) { \
111  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
112  CRYPTO->SEQ1 = a5 | (CRYPTO_CMD_INSTR_END<<8);}
113 #define CRYPTO_SEQ_LOAD_6(a1, a2, a3, a4, a5, a6) { \
114  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
115  CRYPTO->SEQ1 = a5 | (a6<<8) | (CRYPTO_CMD_INSTR_END<<16);}
116 #define CRYPTO_SEQ_LOAD_7(a1, a2, a3, a4, a5, a6, a7) { \
117  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
118  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (CRYPTO_CMD_INSTR_END<<24);}
119 #define CRYPTO_SEQ_LOAD_8(a1, a2, a3, a4, a5, a6, a7, a8) { \
120  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
121  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
122  CRYPTO->SEQ2 = CRYPTO_CMD_INSTR_END;}
123 #define CRYPTO_SEQ_LOAD_9(a1, a2, a3, a4, a5, a6, a7, a8, a9) { \
124  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
125  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
126  CRYPTO->SEQ2 = a9 | (CRYPTO_CMD_INSTR_END<<8);}
127 #define CRYPTO_SEQ_LOAD_10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { \
128  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
129  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
130  CRYPTO->SEQ2 = a9 | (a10<<8) | (CRYPTO_CMD_INSTR_END<<16);}
131 #define CRYPTO_SEQ_LOAD_11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { \
132  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
133  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
134  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (CRYPTO_CMD_INSTR_END<<24);}
135 #define CRYPTO_SEQ_LOAD_12(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { \
136  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
137  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
138  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
139  CRYPTO->SEQ3 = CRYPTO_CMD_INSTR_END;}
140 #define CRYPTO_SEQ_LOAD_13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { \
141  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
142  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
143  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
144  CRYPTO->SEQ3 = a13 | (CRYPTO_CMD_INSTR_END<<8);}
145 #define CRYPTO_SEQ_LOAD_14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { \
146  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
147  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
148  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
149  CRYPTO->SEQ3 = a13 | (a14<<8) | (CRYPTO_CMD_INSTR_END<<16);}
150 #define CRYPTO_SEQ_LOAD_15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { \
151  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
152  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
153  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
154  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (CRYPTO_CMD_INSTR_END<<24);}
155 #define CRYPTO_SEQ_LOAD_16(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { \
156  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
157  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
158  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
159  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
160  CRYPTO->SEQ4 = CRYPTO_CMD_INSTR_END;}
161 #define CRYPTO_SEQ_LOAD_17(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { \
162  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
163  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
164  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
165  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
166  CRYPTO->SEQ4 = a17 | (CRYPTO_CMD_INSTR_END<<8);}
167 #define CRYPTO_SEQ_LOAD_18(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { \
168  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
169  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
170  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
171  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
172  CRYPTO->SEQ4 = a17 | (a18<<8) | (CRYPTO_CMD_INSTR_END<<16);}
173 #define CRYPTO_SEQ_LOAD_19(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { \
174  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
175  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
176  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
177  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
178  CRYPTO->SEQ4 = a17 | (a18<<8) | (a19<<16) | (CRYPTO_CMD_INSTR_END<<24);}
179 #define CRYPTO_SEQ_LOAD_20(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { \
180  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
181  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
182  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
183  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
184  CRYPTO->SEQ4 = a17 | (a18<<8) | (a19<<16) | (a20<<24);}
185 
193 #define CRYPTO_EXECUTE_1(a1) { \
194  CRYPTO->SEQ0 = a1 | (CRYPTO_CMD_INSTR_EXEC<<8); }
195 #define CRYPTO_EXECUTE_2(a1, a2) { \
196  CRYPTO->SEQ0 = a1 | (a2<<8) | (CRYPTO_CMD_INSTR_EXEC<<16); }
197 #define CRYPTO_EXECUTE_3(a1, a2, a3) { \
198  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (CRYPTO_CMD_INSTR_EXEC<<24); }
199 #define CRYPTO_EXECUTE_4(a1, a2, a3, a4) { \
200  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
201  CRYPTO->SEQ1 = CRYPTO_CMD_INSTR_EXEC; }
202 #define CRYPTO_EXECUTE_5(a1, a2, a3, a4, a5) { \
203  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
204  CRYPTO->SEQ1 = a5 | (CRYPTO_CMD_INSTR_EXEC<<8); }
205 #define CRYPTO_EXECUTE_6(a1, a2, a3, a4, a5, a6) { \
206  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
207  CRYPTO->SEQ1 = a5 | (a6<<8) | (CRYPTO_CMD_INSTR_EXEC<<16); }
208 #define CRYPTO_EXECUTE_7(a1, a2, a3, a4, a5, a6, a7) { \
209  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
210  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (CRYPTO_CMD_INSTR_EXEC<<24); }
211 #define CRYPTO_EXECUTE_8(a1, a2, a3, a4, a5, a6, a7, a8) { \
212  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
213  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
214  CRYPTO->SEQ2 = CRYPTO_CMD_INSTR_EXEC; }
215 #define CRYPTO_EXECUTE_9(a1, a2, a3, a4, a5, a6, a7, a8, a9) { \
216  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
217  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
218  CRYPTO->SEQ2 = a9 | (CRYPTO_CMD_INSTR_EXEC<<8); }
219 #define CRYPTO_EXECUTE_10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { \
220  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
221  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
222  CRYPTO->SEQ2 = a9 | (a10<<8) | (CRYPTO_CMD_INSTR_EXEC<<16); }
223 #define CRYPTO_EXECUTE_11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) { \
224  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
225  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
226  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (CRYPTO_CMD_INSTR_EXEC<<24); }
227 #define CRYPTO_EXECUTE_12(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) { \
228  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
229  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
230  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
231  CRYPTO->SEQ3 = CRYPTO_CMD_INSTR_EXEC; }
232 #define CRYPTO_EXECUTE_13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) { \
233  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
234  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
235  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
236  CRYPTO->SEQ3 = a13 | (CRYPTO_CMD_INSTR_EXEC<<8); }
237 #define CRYPTO_EXECUTE_14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) { \
238  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
239  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
240  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
241  CRYPTO->SEQ3 = a13 | (a14<<8) | (CRYPTO_CMD_INSTR_EXEC<<16); }
242 #define CRYPTO_EXECUTE_15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) { \
243  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
244  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
245  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
246  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (CRYPTO_CMD_INSTR_EXEC<<24); }
247 #define CRYPTO_EXECUTE_16(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) { \
248  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
249  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
250  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
251  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
252  CRYPTO->SEQ4 = CRYPTO_CMD_INSTR_EXEC; }
253 #define CRYPTO_EXECUTE_17(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) { \
254  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
255  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
256  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
257  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
258  CRYPTO->SEQ4 = a17 | (CRYPTO_CMD_INSTR_EXEC<<8); }
259 #define CRYPTO_EXECUTE_18(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) { \
260  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
261  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
262  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
263  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
264  CRYPTO->SEQ4 = a17 | (a18<<8) | (CRYPTO_CMD_INSTR_EXEC<<16); }
265 #define CRYPTO_EXECUTE_19(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) { \
266  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
267  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
268  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
269  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
270  CRYPTO->SEQ4 = a17 | (a18<<8) | (a19<<16) | (CRYPTO_CMD_INSTR_EXEC<<24); }
271 #define CRYPTO_EXECUTE_20(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) { \
272  CRYPTO->SEQ0 = a1 | (a2<<8) | (a3<<16) | (a4<<24); \
273  CRYPTO->SEQ1 = a5 | (a6<<8) | (a7<<16) | (a8<<24); \
274  CRYPTO->SEQ2 = a9 | (a10<<8) | (a11<<16) | (a12<<24); \
275  CRYPTO->SEQ3 = a13 | (a14<<8) | (a15<<16) | (a16<<24); \
276  CRYPTO->SEQ4 = a17 | (a18<<8) | (a19<<16) | (a20<<24); \
277  CRYPTO_InstructionSequenceExecute();}
278 
280 /*******************************************************************************
281  ****************************** TYPEDEFS ***********************************
282  ******************************************************************************/
283 
289 typedef uint32_t CRYPTO_Data_TypeDef[CRYPTO_DATA_SIZE_IN_32BIT_WORDS];
290 
296 typedef uint32_t CRYPTO_DData_TypeDef[CRYPTO_DDATA_SIZE_IN_32BIT_WORDS];
297 
299 typedef uint32_t* CRYPTO_DDataPtr_TypeDef;
307 typedef uint32_t CRYPTO_QData_TypeDef[CRYPTO_QDATA_SIZE_IN_32BIT_WORDS];
308 
317 typedef uint32_t CRYPTO_Data260_TypeDef[CRYPTO_DATA260_SIZE_IN_32BIT_WORDS];
318 
323 typedef uint32_t CRYPTO_KeyBuf_TypeDef[CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS];
324 
330 typedef enum
331 {
332  cryptoRegDATA0 = (uint32_t) &CRYPTO->DATA0,
333  cryptoRegDATA1 = (uint32_t) &CRYPTO->DATA1,
334  cryptoRegDATA2 = (uint32_t) &CRYPTO->DATA2,
335  cryptoRegDATA3 = (uint32_t) &CRYPTO->DATA3,
336  cryptoRegDATA0XOR = (uint32_t) &CRYPTO->DATA0XOR,
337 } CRYPTO_DataReg_TypeDef;
338 
344 typedef enum
345 {
346  cryptoRegDDATA0 = (uint32_t) &CRYPTO->DDATA0,
347  cryptoRegDDATA1 = (uint32_t) &CRYPTO->DDATA1,
348  cryptoRegDDATA2 = (uint32_t) &CRYPTO->DDATA2,
349  cryptoRegDDATA3 = (uint32_t) &CRYPTO->DDATA3,
350  cryptoRegDDATA4 = (uint32_t) &CRYPTO->DDATA4,
351  cryptoRegDDATA0BIG = (uint32_t) &CRYPTO->DDATA0BIG,
352 } CRYPTO_DDataReg_TypeDef;
353 
359 typedef enum
360 {
361  cryptoRegQDATA0 = (uint32_t) &CRYPTO->QDATA0,
362  cryptoRegQDATA1 = (uint32_t) &CRYPTO->QDATA1,
363  cryptoRegQDATA1BIG = (uint32_t) &CRYPTO->QDATA1BIG,
364 } CRYPTO_QDataReg_TypeDef;
365 
367 typedef enum
368 {
369  cryptoModulusBin256 = CRYPTO_WAC_MODULUS_BIN256,
370  cryptoModulusBin128 = CRYPTO_WAC_MODULUS_BIN128,
371  cryptoModulusGcmBin128 = CRYPTO_WAC_MODULUS_GCMBIN128,
372  cryptoModulusEccB233 = CRYPTO_WAC_MODULUS_ECCBIN233P,
373  cryptoModulusEccB163 = CRYPTO_WAC_MODULUS_ECCBIN163P,
374  cryptoModulusEccP256 = CRYPTO_WAC_MODULUS_ECCPRIME256P,
375  cryptoModulusEccP224 = CRYPTO_WAC_MODULUS_ECCPRIME224P,
376  cryptoModulusEccP192 = CRYPTO_WAC_MODULUS_ECCPRIME192P,
377  cryptoModulusEccB233Order = CRYPTO_WAC_MODULUS_ECCBIN233N,
378  cryptoModulusEccB233KOrder = CRYPTO_WAC_MODULUS_ECCBIN233KN,
379  cryptoModulusEccB163Order = CRYPTO_WAC_MODULUS_ECCBIN163N,
380  cryptoModulusEccB163KOrder = CRYPTO_WAC_MODULUS_ECCBIN163KN,
381  cryptoModulusEccP256Order = CRYPTO_WAC_MODULUS_ECCPRIME256N,
382  cryptoModulusEccP224Order = CRYPTO_WAC_MODULUS_ECCPRIME224N,
383  cryptoModulusEccP192Order = CRYPTO_WAC_MODULUS_ECCPRIME192N
384 } CRYPTO_ModulusType_TypeDef;
385 
387 typedef enum
388 {
389  cryptoMulOperand256Bits = CRYPTO_WAC_MULWIDTH_MUL256,
390  cryptoMulOperand128Bits = CRYPTO_WAC_MULWIDTH_MUL128,
391  cryptoMulOperandModulusBits = CRYPTO_WAC_MULWIDTH_MULMOD
394 } CRYPTO_MulOperandWidth_TypeDef;
395 
397 typedef enum
398 {
399  cryptoResult128Bits = CRYPTO_WAC_RESULTWIDTH_128BIT,
400  cryptoResult256Bits = CRYPTO_WAC_RESULTWIDTH_256BIT,
401  cryptoResult260Bits = CRYPTO_WAC_RESULTWIDTH_260BIT
402 } CRYPTO_ResultWidth_TypeDef;
403 
405 typedef enum
406 {
407  cryptoInc1byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH1,
408  cryptoInc2byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH2,
409  cryptoInc3byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH3,
410  cryptoInc4byte = CRYPTO_CTRL_INCWIDTH_INCWIDTH4
411 } CRYPTO_IncWidth_TypeDef;
412 
414 typedef enum
415 {
416  cryptoKey128Bits = 8,
417  cryptoKey256Bits = 16,
418 } CRYPTO_KeyWidth_TypeDef;
419 
423 #define CRYPTO_MAX_SEQUENCE_INSTRUCTIONS (20)
424 
432 typedef uint8_t CRYPTO_InstructionSequence_TypeDef[CRYPTO_MAX_SEQUENCE_INSTRUCTIONS];
433 
438 #define CRYPTO_INSTRUCTIONSEQUENSE_DEFAULT \
439  {CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
440  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
441  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
442  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
443  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
444  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END, \
445  CRYPTO_CMD_INSTR_END, CRYPTO_CMD_INSTR_END}
446 
448 typedef uint8_t CRYPTO_SHA1_Digest_TypeDef[CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES];
449 
451 typedef uint8_t CRYPTO_SHA256_Digest_TypeDef[CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES];
452 
464 typedef void (*CRYPTO_AES_CtrFuncPtr_TypeDef)(uint8_t * ctr);
465 
466 /*******************************************************************************
467  ***************************** PROTOTYPES **********************************
468  ******************************************************************************/
469 
470 /***************************************************************************/
480 void CRYPTO_ModulusSet(CRYPTO_ModulusType_TypeDef modType);
481 
482 /***************************************************************************/
492 __STATIC_INLINE void CRYPTO_MulOperandWidthSet(CRYPTO_MulOperandWidth_TypeDef mulOperandWidth)
493 {
494  uint32_t temp = CRYPTO->WAC & (~_CRYPTO_WAC_MULWIDTH_MASK);
495  CRYPTO->WAC = temp | mulOperandWidth;
496 }
497 
498 /***************************************************************************/
507 __STATIC_INLINE void CRYPTO_ResultWidthSet(CRYPTO_ResultWidth_TypeDef resultWidth)
508 {
509  uint32_t temp = CRYPTO->WAC & (~_CRYPTO_WAC_RESULTWIDTH_MASK);
510  CRYPTO->WAC = temp | resultWidth;
511 }
512 
513 /***************************************************************************/
523 __STATIC_INLINE void CRYPTO_IncWidthSet(CRYPTO_IncWidth_TypeDef incWidth)
524 {
525  uint32_t temp = CRYPTO->CTRL & (~_CRYPTO_CTRL_INCWIDTH_MASK);
526  CRYPTO->CTRL = temp | incWidth;
527 }
528 
529 /***************************************************************************/
546 __STATIC_INLINE void CRYPTO_BurstToCrypto(volatile uint32_t * reg, const uint32_t * val)
547 {
548  /* Load data from memory into local registers. */
549  register uint32_t v0 = val[0];
550  register uint32_t v1 = val[1];
551  register uint32_t v2 = val[2];
552  register uint32_t v3 = val[3];
553  /* Store data to CRYPTO */
554  *reg = v0;
555  *reg = v1;
556  *reg = v2;
557  *reg = v3;
558 }
559 
560 /***************************************************************************/
577 __STATIC_INLINE void CRYPTO_BurstFromCrypto(volatile uint32_t * reg, uint32_t * val)
578 {
579  /* Load data from CRYPTO into local registers. */
580  register uint32_t v0 = *reg;
581  register uint32_t v1 = *reg;
582  register uint32_t v2 = *reg;
583  register uint32_t v3 = *reg;
584  /* Store data to memory */
585  val[0] = v0;
586  val[1] = v1;
587  val[2] = v2;
588  val[3] = v3;
589 }
590 
591 /***************************************************************************/
603 __STATIC_INLINE void CRYPTO_DataWrite(CRYPTO_DataReg_TypeDef dataReg,
604  const CRYPTO_Data_TypeDef val)
605 {
606  CRYPTO_BurstToCrypto((volatile uint32_t *)dataReg, val);
607 }
608 
609 /***************************************************************************/
621 __STATIC_INLINE void CRYPTO_DataRead(CRYPTO_DataReg_TypeDef dataReg,
622  CRYPTO_Data_TypeDef val)
623 {
624  CRYPTO_BurstFromCrypto((volatile uint32_t *)dataReg, val);
625 }
626 
627 /***************************************************************************/
639 __STATIC_INLINE void CRYPTO_DDataWrite(CRYPTO_DDataReg_TypeDef ddataReg,
640  const CRYPTO_DData_TypeDef val)
641 {
642  CRYPTO_BurstToCrypto((volatile uint32_t *)ddataReg, &val[0]);
643  CRYPTO_BurstToCrypto((volatile uint32_t *)ddataReg, &val[4]);
644 }
645 
646 /***************************************************************************/
658 __STATIC_INLINE void CRYPTO_DDataRead(CRYPTO_DDataReg_TypeDef ddataReg,
659  CRYPTO_DData_TypeDef val)
660 {
661  CRYPTO_BurstFromCrypto((volatile uint32_t *)ddataReg, &val[0]);
662  CRYPTO_BurstFromCrypto((volatile uint32_t *)ddataReg, &val[4]);
663 }
664 
665 /***************************************************************************/
677 __STATIC_INLINE void CRYPTO_QDataWrite(CRYPTO_QDataReg_TypeDef qdataReg,
678  CRYPTO_QData_TypeDef val)
679 {
680  CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[0]);
681  CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[4]);
682  CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[8]);
683  CRYPTO_BurstToCrypto((volatile uint32_t *)qdataReg, &val[12]);
684 }
685 
686 /***************************************************************************/
698 __STATIC_INLINE void CRYPTO_QDataRead(CRYPTO_QDataReg_TypeDef qdataReg,
699  CRYPTO_QData_TypeDef val)
700 {
701  CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[0]);
702  CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[4]);
703  CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[8]);
704  CRYPTO_BurstFromCrypto((volatile uint32_t *)qdataReg, &val[12]);
705 }
706 
707 /***************************************************************************/
717 __STATIC_INLINE void CRYPTO_KeyBufWrite(CRYPTO_KeyBuf_TypeDef val,
718  CRYPTO_KeyWidth_TypeDef keyWidth)
719 {
720  if (keyWidth == cryptoKey256Bits)
721  {
722  /* Set AES-256 mode */
723  BUS_RegBitWrite(&CRYPTO->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES256);
724  /* Load key in KEYBUF register (= DDATA4) */
725  CRYPTO_DDataWrite(cryptoRegDDATA4, (uint32_t *)val);
726  }
727  else
728  {
729  /* Set AES-128 mode */
730  BUS_RegBitWrite(&CRYPTO->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES128);
731  CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, &val[0]);
732  }
733 }
734 
735 void CRYPTO_KeyRead(CRYPTO_KeyBuf_TypeDef val,
736  CRYPTO_KeyWidth_TypeDef keyWidth);
737 
738 /***************************************************************************/
747 __STATIC_INLINE void CRYPTO_KeyBuf128Write(const uint32_t * val)
748 {
749  CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, val);
750 }
751 
752 /***************************************************************************/
762 __STATIC_INLINE bool CRYPTO_CarryIsSet(void)
763 {
764  return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_CARRY_MASK)
765  >> _CRYPTO_DSTATUS_CARRY_SHIFT;
766 }
767 
768 /***************************************************************************/
779 __STATIC_INLINE uint8_t CRYPTO_DData0_4LSBitsRead(void)
780 {
781  return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA0LSBS_MASK)
782  >> _CRYPTO_DSTATUS_DDATA0LSBS_SHIFT;
783 }
784 
785 /***************************************************************************/
797 __STATIC_INLINE void CRYPTO_DData0Read260(CRYPTO_Data260_TypeDef val)
798 {
799  CRYPTO_DDataRead(cryptoRegDDATA0, val);
800  val[8] = (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA0MSBS_MASK)
801  >> _CRYPTO_DSTATUS_DDATA0MSBS_SHIFT;
802 }
803 
804 /***************************************************************************/
816 __STATIC_INLINE void CRYPTO_DData0Write260(const CRYPTO_Data260_TypeDef val)
817 {
818  CRYPTO_DDataWrite(cryptoRegDDATA0, val);
819  CRYPTO->DDATA0BYTE32 = val[8] & _CRYPTO_DDATA0BYTE32_DDATA0BYTE32_MASK;
820 }
821 
822 /***************************************************************************/
835 __STATIC_INLINE bool CRYPTO_DData1_MSBitRead(void)
836 {
837  return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA1MSB_MASK)
838  >> _CRYPTO_DSTATUS_DDATA1MSB_SHIFT;
839 }
840 
841 /***************************************************************************/
853 __STATIC_INLINE void CRYPTO_InstructionSequenceLoad(const CRYPTO_InstructionSequence_TypeDef instructionSequence)
854 {
855  const uint32_t * pas = (const uint32_t *) instructionSequence;
856 
857  CRYPTO->SEQ0 = pas[0];
858  CRYPTO->SEQ1 = pas[1];
859  CRYPTO->SEQ2 = pas[2];
860  CRYPTO->SEQ3 = pas[3];
861  CRYPTO->SEQ4 = pas[4];
862 }
863 
864 /***************************************************************************/
872 __STATIC_INLINE void CRYPTO_InstructionSequenceExecute(void)
873 {
874  /* Start the command sequence. */
875  CRYPTO->CMD = CRYPTO_CMD_SEQSTART;
876 }
877 
878 /***************************************************************************/
888 __STATIC_INLINE bool CRYPTO_InstructionSequenceDone(void)
889 {
890  /* Return true if operation has completed. */
891  return !(CRYPTO->STATUS
892  & (CRYPTO_STATUS_INSTRRUNNING | CRYPTO_STATUS_SEQRUNNING));
893 }
894 
895 /***************************************************************************/
903 __STATIC_INLINE void CRYPTO_InstructionSequenceWait(void)
904 {
905  while (!CRYPTO_InstructionSequenceDone())
906  ;
907 }
908 
909 /***************************************************************************/
917 __STATIC_INLINE void CRYPTO_InstructionWait(void)
918 {
919  /* Wait for completion */
920  while (!(CRYPTO->IF & CRYPTO_IF_INSTRDONE))
921  ;
922  CRYPTO->IFC = CRYPTO_IF_INSTRDONE;
923 }
924 
925 void CRYPTO_SHA_1(const uint8_t * msg,
926  uint64_t msgLen,
927  CRYPTO_SHA1_Digest_TypeDef digest);
928 
929 void CRYPTO_SHA_256(const uint8_t * msg,
930  uint64_t msgLen,
931  CRYPTO_SHA256_Digest_TypeDef digest);
932 
933 void CRYPTO_Mul(uint32_t * A, int aSize,
934  uint32_t * B, int bSize,
935  uint32_t * R, int rSize);
936 
937 void CRYPTO_AES_CBC128(uint8_t * out,
938  const uint8_t * in,
939  unsigned int len,
940  const uint8_t * key,
941  const uint8_t * iv,
942  bool encrypt);
943 
944 void CRYPTO_AES_CBC256(uint8_t * out,
945  const uint8_t * in,
946  unsigned int len,
947  const uint8_t * key,
948  const uint8_t * iv,
949  bool encrypt);
950 
951 void CRYPTO_AES_CFB128(uint8_t * out,
952  const uint8_t * in,
953  unsigned int len,
954  const uint8_t * key,
955  const uint8_t * iv,
956  bool encrypt);
957 
958 void CRYPTO_AES_CFB256(uint8_t * out,
959  const uint8_t * in,
960  unsigned int len,
961  const uint8_t * key,
962  const uint8_t * iv,
963  bool encrypt);
964 
965 void CRYPTO_AES_CTR128(uint8_t * out,
966  const uint8_t * in,
967  unsigned int len,
968  const uint8_t * key,
969  uint8_t * ctr,
970  CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
971 
972 void CRYPTO_AES_CTR256(uint8_t * out,
973  const uint8_t * in,
974  unsigned int len,
975  const uint8_t * key,
976  uint8_t * ctr,
977  CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
978 
979 void CRYPTO_AES_CTRUpdate32Bit(uint8_t * ctr);
980 void CRYPTO_AES_DecryptKey128(uint8_t * out, const uint8_t * in);
981 void CRYPTO_AES_DecryptKey256(uint8_t * out, const uint8_t * in);
982 
983 void CRYPTO_AES_ECB128(uint8_t * out,
984  const uint8_t * in,
985  unsigned int len,
986  const uint8_t * key,
987  bool encrypt);
988 
989 void CRYPTO_AES_ECB256(uint8_t * out,
990  const uint8_t * in,
991  unsigned int len,
992  const uint8_t * key,
993  bool encrypt);
994 
995 void CRYPTO_AES_OFB128(uint8_t * out,
996  const uint8_t * in,
997  unsigned int len,
998  const uint8_t * key,
999  const uint8_t * iv);
1000 
1001 void CRYPTO_AES_OFB256(uint8_t * out,
1002  const uint8_t * in,
1003  unsigned int len,
1004  const uint8_t * key,
1005  const uint8_t * iv);
1006 
1007 /***************************************************************************/
1015 __STATIC_INLINE void CRYPTO_IntClear(uint32_t flags)
1016 {
1017  CRYPTO->IFC = flags;
1018 }
1019 
1020 /***************************************************************************/
1028 __STATIC_INLINE void CRYPTO_IntDisable(uint32_t flags)
1029 {
1030  CRYPTO->IEN &= ~(flags);
1031 }
1032 
1033 /***************************************************************************/
1046 __STATIC_INLINE void CRYPTO_IntEnable(uint32_t flags)
1047 {
1048  CRYPTO->IEN |= flags;
1049 }
1050 
1051 /***************************************************************************/
1062 __STATIC_INLINE uint32_t CRYPTO_IntGet(void)
1063 {
1064  return CRYPTO->IF;
1065 }
1066 
1067 /***************************************************************************/
1081 __STATIC_INLINE uint32_t CRYPTO_IntGetEnabled(void)
1082 {
1083  return CRYPTO->IF & CRYPTO->IEN;
1084 }
1085 
1086 /***************************************************************************/
1094 __STATIC_INLINE void CRYPTO_IntSet(uint32_t flags)
1095 {
1096  CRYPTO->IFS = flags;
1097 }
1098 
1099 /*******************************************************************************
1100  ***** Static inline wrappers for CRYPTO AES functions in order to *****
1101  ***** preserve backwards compatibility with AES module API functions. *****
1102  ******************************************************************************/
1103 
1104 /***************************************************************************/
1113 __STATIC_INLINE void AES_CBC128(uint8_t * out,
1114  const uint8_t * in,
1115  unsigned int len,
1116  const uint8_t * key,
1117  const uint8_t * iv,
1118  bool encrypt)
1119 {
1120  CRYPTO_AES_CBC128(out, in, len, key, iv, encrypt);
1121 }
1122 
1123 /***************************************************************************/
1132 __STATIC_INLINE void AES_CBC256(uint8_t * out,
1133  const uint8_t * in,
1134  unsigned int len,
1135  const uint8_t * key,
1136  const uint8_t * iv,
1137  bool encrypt)
1138 {
1139  CRYPTO_AES_CBC256(out, in, len, key, iv, encrypt);
1140 }
1141 
1142 /***************************************************************************/
1150 __STATIC_INLINE void AES_CFB128(uint8_t * out,
1151  const uint8_t * in,
1152  unsigned int len,
1153  const uint8_t * key,
1154  const uint8_t * iv,
1155  bool encrypt)
1156 {
1157  CRYPTO_AES_CFB128(out, in, len, key, iv, encrypt);
1158 }
1159 
1160 /***************************************************************************/
1168 __STATIC_INLINE void AES_CFB256(uint8_t * out,
1169  const uint8_t * in,
1170  unsigned int len,
1171  const uint8_t * key,
1172  const uint8_t * iv,
1173  bool encrypt)
1174 {
1175  CRYPTO_AES_CFB256(out, in, len, key, iv, encrypt);
1176 }
1177 
1178 /***************************************************************************/
1186 __STATIC_INLINE void AES_CTR128(uint8_t * out,
1187  const uint8_t * in,
1188  unsigned int len,
1189  const uint8_t * key,
1190  uint8_t * ctr,
1191  CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1192 {
1193  CRYPTO_AES_CTR128(out, in, len, key, ctr, ctrFunc);
1194 }
1195 
1196 /***************************************************************************/
1204 __STATIC_INLINE void AES_CTR256(uint8_t * out,
1205  const uint8_t * in,
1206  unsigned int len,
1207  const uint8_t * key,
1208  uint8_t * ctr,
1209  CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1210 {
1211  CRYPTO_AES_CTR256(out, in, len, key, ctr, ctrFunc);
1212 }
1213 
1214 /***************************************************************************/
1222 __STATIC_INLINE void AES_CTRUpdate32Bit(uint8_t * ctr)
1223 {
1224  CRYPTO_AES_CTRUpdate32Bit(ctr);
1225 }
1226 
1227 /***************************************************************************/
1236 __STATIC_INLINE void AES_DecryptKey128(uint8_t * out, const uint8_t * in)
1237 {
1238  CRYPTO_AES_DecryptKey128(out, in);
1239 }
1240 
1241 /***************************************************************************/
1250 __STATIC_INLINE void AES_DecryptKey256(uint8_t * out, const uint8_t * in)
1251 {
1252  CRYPTO_AES_DecryptKey256(out, in);
1253 }
1254 
1255 /***************************************************************************/
1264 __STATIC_INLINE void AES_ECB128(uint8_t * out,
1265  const uint8_t * in,
1266  unsigned int len,
1267  const uint8_t * key,
1268  bool encrypt)
1269 {
1270  CRYPTO_AES_ECB128(out, in, len, key, encrypt);
1271 }
1272 
1273 /***************************************************************************/
1282 __STATIC_INLINE void AES_ECB256(uint8_t * out,
1283  const uint8_t * in,
1284  unsigned int len,
1285  const uint8_t * key,
1286  bool encrypt)
1287 {
1288  CRYPTO_AES_ECB256(out, in, len, key, encrypt);
1289 }
1290 
1291 /***************************************************************************/
1299 __STATIC_INLINE void AES_OFB128(uint8_t * out,
1300  const uint8_t * in,
1301  unsigned int len,
1302  const uint8_t * key,
1303  const uint8_t * iv)
1304 {
1305  CRYPTO_AES_OFB128(out, in, len, key, iv);
1306 }
1307 
1308 /***************************************************************************/
1316 __STATIC_INLINE void AES_OFB256(uint8_t * out,
1317  const uint8_t * in,
1318  unsigned int len,
1319  const uint8_t * key,
1320  const uint8_t * iv)
1321 {
1322  CRYPTO_AES_OFB256(out, in, len, key, iv);
1323 }
1324 
1325 #ifdef __cplusplus
1326 }
1327 #endif
1328 
1332 #endif /* defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0) */
1333 
1334 #endif /* __SILICON_LABS_EM_CRYPTO_H__ */
void AES_CTRUpdate32Bit(uint8_t *ctr)
Update last 32 bits of 128 bit counter, by incrementing with 1.
Definition: em_aes.c:883
void AES_DecryptKey128(uint8_t *out, const uint8_t *in)
Generate 128 bit decryption key from 128 bit encryption key. The decryption key is used for some ciph...
Definition: em_aes.c:906
RAM and peripheral bit-field set and clear API.
void AES_CFB256(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv, bool encrypt)
Cipher feedback (CFB) cipher mode encryption/decryption, 256 bit key.
Definition: em_aes.c:595
CMSIS Cortex-M Peripheral Access Layer for Silicon Laboratories microcontroller devices.
void AES_CTR128(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, uint8_t *ctr, AES_CtrFuncPtr_TypeDef ctrFunc)
Counter (CTR) cipher mode encryption/decryption, 128 bit key.
Definition: em_aes.c:720
void AES_OFB256(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv)
Output feedback (OFB) cipher mode encryption/decryption, 256 bit key.
Definition: em_aes.c:1332
void AES_CTR256(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, uint8_t *ctr, AES_CtrFuncPtr_TypeDef ctrFunc)
Counter (CTR) cipher mode encryption/decryption, 256 bit key.
Definition: em_aes.c:818
void AES_OFB128(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv)
Output feedback (OFB) cipher mode encryption/decryption, 128 bit key.
Definition: em_aes.c:1246
void AES_CBC128(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv, bool encrypt)
Cipher-block chaining (CBC) cipher mode encryption/decryption, 128 bit key.
Definition: em_aes.c:157
void AES_CBC256(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv, bool encrypt)
Cipher-block chaining (CBC) cipher mode encryption/decryption, 256 bit key.
Definition: em_aes.c:322
void AES_DecryptKey256(uint8_t *out, const uint8_t *in)
Generate 256 bit decryption key from 256 bit encryption key. The decryption key is used for some ciph...
Definition: em_aes.c:951
__STATIC_INLINE void BUS_RegBitWrite(volatile uint32_t *addr, unsigned int bit, unsigned int val)
Perform a single-bit write operation on a peripheral register.
Definition: em_bus.h:146
void AES_ECB256(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, bool encrypt)
Electronic Codebook (ECB) cipher mode encryption/decryption, 256 bit key.
Definition: em_aes.c:1135
void AES_ECB128(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, bool encrypt)
Electronic Codebook (ECB) cipher mode encryption/decryption, 128 bit key.
Definition: em_aes.c:1034
void AES_CFB128(uint8_t *out, const uint8_t *in, unsigned int len, const uint8_t *key, const uint8_t *iv, bool encrypt)
Cipher feedback (CFB) cipher mode encryption/decryption, 128 bit key.
Definition: em_aes.c:486