32 #ifndef __SILICON_LABS_EM_CRYPTO_H__
33 #define __SILICON_LABS_EM_CRYPTO_H__
37 #if defined(CRYPTO_COUNT) && (CRYPTO_COUNT > 0)
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))
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))
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))
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))
78 #define CRYPTO_DATA260_SIZE_IN_32BIT_WORDS (9)
81 #define CRYPTO_SHA1_DIGEST_SIZE_IN_BITS (160)
82 #define CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA1_DIGEST_SIZE_IN_BITS/8)
85 #define CRYPTO_SHA256_DIGEST_SIZE_IN_BITS (256)
86 #define CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES (CRYPTO_SHA256_DIGEST_SIZE_IN_BITS/8)
91 #define CRYPTO_DDATA0_260_BITS_READ(bigint260) CRYPTO_DData0Read260(bigint260)
92 #define CRYPTO_DDATA0_260_BITS_WRITE(bigint260) CRYPTO_DData0Write260(bigint260)
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);}
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();}
289 typedef uint32_t CRYPTO_Data_TypeDef[CRYPTO_DATA_SIZE_IN_32BIT_WORDS];
296 typedef uint32_t CRYPTO_DData_TypeDef[CRYPTO_DDATA_SIZE_IN_32BIT_WORDS];
299 typedef uint32_t* CRYPTO_DDataPtr_TypeDef;
307 typedef uint32_t CRYPTO_QData_TypeDef[CRYPTO_QDATA_SIZE_IN_32BIT_WORDS];
317 typedef uint32_t CRYPTO_Data260_TypeDef[CRYPTO_DATA260_SIZE_IN_32BIT_WORDS];
323 typedef uint32_t CRYPTO_KeyBuf_TypeDef[CRYPTO_KEYBUF_SIZE_IN_32BIT_WORDS];
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;
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;
361 cryptoRegQDATA0 = (uint32_t) &CRYPTO->QDATA0,
362 cryptoRegQDATA1 = (uint32_t) &CRYPTO->QDATA1,
363 cryptoRegQDATA1BIG = (uint32_t) &CRYPTO->QDATA1BIG,
364 } CRYPTO_QDataReg_TypeDef;
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;
389 cryptoMulOperand256Bits = CRYPTO_WAC_MULWIDTH_MUL256,
390 cryptoMulOperand128Bits = CRYPTO_WAC_MULWIDTH_MUL128,
391 cryptoMulOperandModulusBits = CRYPTO_WAC_MULWIDTH_MULMOD
394 } CRYPTO_MulOperandWidth_TypeDef;
399 cryptoResult128Bits = CRYPTO_WAC_RESULTWIDTH_128BIT,
400 cryptoResult256Bits = CRYPTO_WAC_RESULTWIDTH_256BIT,
401 cryptoResult260Bits = CRYPTO_WAC_RESULTWIDTH_260BIT
402 } CRYPTO_ResultWidth_TypeDef;
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;
416 cryptoKey128Bits = 8,
417 cryptoKey256Bits = 16,
418 } CRYPTO_KeyWidth_TypeDef;
423 #define CRYPTO_MAX_SEQUENCE_INSTRUCTIONS (20)
432 typedef uint8_t CRYPTO_InstructionSequence_TypeDef[CRYPTO_MAX_SEQUENCE_INSTRUCTIONS];
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}
448 typedef uint8_t CRYPTO_SHA1_Digest_TypeDef[CRYPTO_SHA1_DIGEST_SIZE_IN_BYTES];
451 typedef uint8_t CRYPTO_SHA256_Digest_TypeDef[CRYPTO_SHA256_DIGEST_SIZE_IN_BYTES];
464 typedef void (*CRYPTO_AES_CtrFuncPtr_TypeDef)(uint8_t * ctr);
480 void CRYPTO_ModulusSet(CRYPTO_ModulusType_TypeDef modType);
492 __STATIC_INLINE
void CRYPTO_MulOperandWidthSet(CRYPTO_MulOperandWidth_TypeDef mulOperandWidth)
494 uint32_t temp = CRYPTO->WAC & (~_CRYPTO_WAC_MULWIDTH_MASK);
495 CRYPTO->WAC = temp | mulOperandWidth;
507 __STATIC_INLINE
void CRYPTO_ResultWidthSet(CRYPTO_ResultWidth_TypeDef resultWidth)
509 uint32_t temp = CRYPTO->WAC & (~_CRYPTO_WAC_RESULTWIDTH_MASK);
510 CRYPTO->WAC = temp | resultWidth;
523 __STATIC_INLINE
void CRYPTO_IncWidthSet(CRYPTO_IncWidth_TypeDef incWidth)
525 uint32_t temp = CRYPTO->CTRL & (~_CRYPTO_CTRL_INCWIDTH_MASK);
526 CRYPTO->CTRL = temp | incWidth;
546 __STATIC_INLINE
void CRYPTO_BurstToCrypto(
volatile uint32_t * reg,
const uint32_t * val)
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];
577 __STATIC_INLINE
void CRYPTO_BurstFromCrypto(
volatile uint32_t * reg, uint32_t * val)
580 register uint32_t v0 = *reg;
581 register uint32_t v1 = *reg;
582 register uint32_t v2 = *reg;
583 register uint32_t v3 = *reg;
603 __STATIC_INLINE
void CRYPTO_DataWrite(CRYPTO_DataReg_TypeDef dataReg,
604 const CRYPTO_Data_TypeDef val)
606 CRYPTO_BurstToCrypto((
volatile uint32_t *)dataReg, val);
621 __STATIC_INLINE
void CRYPTO_DataRead(CRYPTO_DataReg_TypeDef dataReg,
622 CRYPTO_Data_TypeDef val)
624 CRYPTO_BurstFromCrypto((
volatile uint32_t *)dataReg, val);
639 __STATIC_INLINE
void CRYPTO_DDataWrite(CRYPTO_DDataReg_TypeDef ddataReg,
640 const CRYPTO_DData_TypeDef val)
642 CRYPTO_BurstToCrypto((
volatile uint32_t *)ddataReg, &val[0]);
643 CRYPTO_BurstToCrypto((
volatile uint32_t *)ddataReg, &val[4]);
658 __STATIC_INLINE
void CRYPTO_DDataRead(CRYPTO_DDataReg_TypeDef ddataReg,
659 CRYPTO_DData_TypeDef val)
661 CRYPTO_BurstFromCrypto((
volatile uint32_t *)ddataReg, &val[0]);
662 CRYPTO_BurstFromCrypto((
volatile uint32_t *)ddataReg, &val[4]);
677 __STATIC_INLINE
void CRYPTO_QDataWrite(CRYPTO_QDataReg_TypeDef qdataReg,
678 CRYPTO_QData_TypeDef val)
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]);
698 __STATIC_INLINE
void CRYPTO_QDataRead(CRYPTO_QDataReg_TypeDef qdataReg,
699 CRYPTO_QData_TypeDef val)
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]);
717 __STATIC_INLINE
void CRYPTO_KeyBufWrite(CRYPTO_KeyBuf_TypeDef val,
718 CRYPTO_KeyWidth_TypeDef keyWidth)
720 if (keyWidth == cryptoKey256Bits)
723 BUS_RegBitWrite(&CRYPTO->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES256);
725 CRYPTO_DDataWrite(cryptoRegDDATA4, (uint32_t *)val);
730 BUS_RegBitWrite(&CRYPTO->CTRL, _CRYPTO_CTRL_AES_SHIFT, _CRYPTO_CTRL_AES_AES128);
731 CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, &val[0]);
735 void CRYPTO_KeyRead(CRYPTO_KeyBuf_TypeDef val,
736 CRYPTO_KeyWidth_TypeDef keyWidth);
747 __STATIC_INLINE
void CRYPTO_KeyBuf128Write(
const uint32_t * val)
749 CRYPTO_BurstToCrypto(&CRYPTO->KEYBUF, val);
762 __STATIC_INLINE
bool CRYPTO_CarryIsSet(
void)
764 return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_CARRY_MASK)
765 >> _CRYPTO_DSTATUS_CARRY_SHIFT;
779 __STATIC_INLINE uint8_t CRYPTO_DData0_4LSBitsRead(
void)
781 return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA0LSBS_MASK)
782 >> _CRYPTO_DSTATUS_DDATA0LSBS_SHIFT;
797 __STATIC_INLINE
void CRYPTO_DData0Read260(CRYPTO_Data260_TypeDef val)
799 CRYPTO_DDataRead(cryptoRegDDATA0, val);
800 val[8] = (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA0MSBS_MASK)
801 >> _CRYPTO_DSTATUS_DDATA0MSBS_SHIFT;
816 __STATIC_INLINE
void CRYPTO_DData0Write260(
const CRYPTO_Data260_TypeDef val)
818 CRYPTO_DDataWrite(cryptoRegDDATA0, val);
819 CRYPTO->DDATA0BYTE32 = val[8] & _CRYPTO_DDATA0BYTE32_DDATA0BYTE32_MASK;
835 __STATIC_INLINE
bool CRYPTO_DData1_MSBitRead(
void)
837 return (CRYPTO->DSTATUS & _CRYPTO_DSTATUS_DDATA1MSB_MASK)
838 >> _CRYPTO_DSTATUS_DDATA1MSB_SHIFT;
853 __STATIC_INLINE
void CRYPTO_InstructionSequenceLoad(
const CRYPTO_InstructionSequence_TypeDef instructionSequence)
855 const uint32_t * pas = (
const uint32_t *) instructionSequence;
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];
872 __STATIC_INLINE
void CRYPTO_InstructionSequenceExecute(
void)
875 CRYPTO->CMD = CRYPTO_CMD_SEQSTART;
888 __STATIC_INLINE
bool CRYPTO_InstructionSequenceDone(
void)
891 return !(CRYPTO->STATUS
892 & (CRYPTO_STATUS_INSTRRUNNING | CRYPTO_STATUS_SEQRUNNING));
903 __STATIC_INLINE
void CRYPTO_InstructionSequenceWait(
void)
905 while (!CRYPTO_InstructionSequenceDone())
917 __STATIC_INLINE
void CRYPTO_InstructionWait(
void)
920 while (!(CRYPTO->IF & CRYPTO_IF_INSTRDONE))
922 CRYPTO->IFC = CRYPTO_IF_INSTRDONE;
925 void CRYPTO_SHA_1(
const uint8_t * msg,
927 CRYPTO_SHA1_Digest_TypeDef digest);
929 void CRYPTO_SHA_256(
const uint8_t * msg,
931 CRYPTO_SHA256_Digest_TypeDef digest);
933 void CRYPTO_Mul(uint32_t * A,
int aSize,
934 uint32_t * B,
int bSize,
935 uint32_t * R,
int rSize);
937 void CRYPTO_AES_CBC128(uint8_t * out,
944 void CRYPTO_AES_CBC256(uint8_t * out,
951 void CRYPTO_AES_CFB128(uint8_t * out,
958 void CRYPTO_AES_CFB256(uint8_t * out,
965 void CRYPTO_AES_CTR128(uint8_t * out,
970 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
972 void CRYPTO_AES_CTR256(uint8_t * out,
977 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc);
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);
983 void CRYPTO_AES_ECB128(uint8_t * out,
989 void CRYPTO_AES_ECB256(uint8_t * out,
995 void CRYPTO_AES_OFB128(uint8_t * out,
1001 void CRYPTO_AES_OFB256(uint8_t * out,
1004 const uint8_t * key,
1005 const uint8_t * iv);
1015 __STATIC_INLINE
void CRYPTO_IntClear(uint32_t flags)
1017 CRYPTO->IFC = flags;
1028 __STATIC_INLINE
void CRYPTO_IntDisable(uint32_t flags)
1030 CRYPTO->IEN &= ~(flags);
1046 __STATIC_INLINE
void CRYPTO_IntEnable(uint32_t flags)
1048 CRYPTO->IEN |= flags;
1062 __STATIC_INLINE uint32_t CRYPTO_IntGet(
void)
1081 __STATIC_INLINE uint32_t CRYPTO_IntGetEnabled(
void)
1083 return CRYPTO->IF & CRYPTO->IEN;
1094 __STATIC_INLINE
void CRYPTO_IntSet(uint32_t flags)
1096 CRYPTO->IFS = flags;
1113 __STATIC_INLINE
void AES_CBC128(uint8_t * out,
1116 const uint8_t * key,
1120 CRYPTO_AES_CBC128(out, in, len, key, iv, encrypt);
1132 __STATIC_INLINE
void AES_CBC256(uint8_t * out,
1135 const uint8_t * key,
1139 CRYPTO_AES_CBC256(out, in, len, key, iv, encrypt);
1150 __STATIC_INLINE
void AES_CFB128(uint8_t * out,
1153 const uint8_t * key,
1157 CRYPTO_AES_CFB128(out, in, len, key, iv, encrypt);
1168 __STATIC_INLINE
void AES_CFB256(uint8_t * out,
1171 const uint8_t * key,
1175 CRYPTO_AES_CFB256(out, in, len, key, iv, encrypt);
1186 __STATIC_INLINE
void AES_CTR128(uint8_t * out,
1189 const uint8_t * key,
1191 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1193 CRYPTO_AES_CTR128(out, in, len, key, ctr, ctrFunc);
1204 __STATIC_INLINE
void AES_CTR256(uint8_t * out,
1207 const uint8_t * key,
1209 CRYPTO_AES_CtrFuncPtr_TypeDef ctrFunc)
1211 CRYPTO_AES_CTR256(out, in, len, key, ctr, ctrFunc);
1224 CRYPTO_AES_CTRUpdate32Bit(ctr);
1238 CRYPTO_AES_DecryptKey128(out, in);
1250 __STATIC_INLINE
void AES_DecryptKey256(uint8_t * out,
const uint8_t * in)
1252 CRYPTO_AES_DecryptKey256(out, in);
1264 __STATIC_INLINE
void AES_ECB128(uint8_t * out,
1267 const uint8_t * key,
1270 CRYPTO_AES_ECB128(out, in, len, key, encrypt);
1282 __STATIC_INLINE
void AES_ECB256(uint8_t * out,
1285 const uint8_t * key,
1288 CRYPTO_AES_ECB256(out, in, len, key, encrypt);
1299 __STATIC_INLINE
void AES_OFB128(uint8_t * out,
1302 const uint8_t * key,
1305 CRYPTO_AES_OFB128(out, in, len, key, iv);
1316 __STATIC_INLINE
void AES_OFB256(uint8_t * out,
1319 const uint8_t * key,
1322 CRYPTO_AES_OFB256(out, in, len, key, iv);
void AES_CTRUpdate32Bit(uint8_t *ctr)
Update last 32 bits of 128 bit counter, by incrementing with 1.
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...
RAM and peripheral bit-field set and clear API.
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.
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.
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.
__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.
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.
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.