ll_pkc.h
Go to the documentation of this file.
1 /**
2  ****************************************************************************************
3  *
4  * @file ll_pkc.h
5  * @author BLE Driver Team
6  * @brief Header file containing functions prototypes of PKC LL library.
7  *
8  ****************************************************************************************
9  * @attention
10  #####Copyright (c) 2019 GOODIX
11  All rights reserved.
12 
13  Redistribution and use in source and binary forms, with or without
14  modification, are permitted provided that the following conditions are met:
15  * Redistributions of source code must retain the above copyright
16  notice, this list of conditions and the following disclaimer.
17  * Redistributions in binary form must reproduce the above copyright
18  notice, this list of conditions and the following disclaimer in the
19  documentation and/or other materials provided with the distribution.
20  * Neither the name of GOODIX nor the names of its contributors may be used
21  to endorse or promote products derived from this software without
22  specific prior written permission.
23 
24  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
28  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  POSSIBILITY OF SUCH DAMAGE.
35  ****************************************************************************************
36  */
37 
38 /** @addtogroup PERIPHERAL Peripheral Driver
39  * @{
40  */
41 
42 /** @addtogroup LL_DRIVER LL Driver
43  * @{
44  */
45 
46 /** @defgroup LL_PKC PKC
47  * @brief PKC LL module driver.
48  * @{
49  */
50 
51 /* Define to prevent recursive inclusion -------------------------------------*/
52 #ifndef __GR5XX_LL_PKC_H__
53 #define __GR5XX_LL_PKC_H__
54 
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58 
59 /* Includes ------------------------------------------------------------------*/
60 #include "gr5x.h"
61 
62 #if defined (PKC)
63 
64 /** @addtogroup PKC_LL_MACRO
65  * @{
66  */
67 
68 /* Private macros ------------------------------------------------------------*/
69 /** @defgroup PKC_LL_Private_Macro PKC Private Macros
70  * @{
71  */
72 #define ECC_U32_LENGTH (8U) /**< ECC Array Length */
73 #define RSA_U32_LENGTH (64U) /**< RSA Array Length */
74 
75 /** @} */
76 
77 /** @} */
78 
79 /** @defgroup PKC_LL_STRUCTURES Structures
80  * @{
81  */
82 
83 /* Exported types ------------------------------------------------------------*/
84 /** @defgroup PKC_LL_ES_INIT PKC Exported Init structures
85  * @{
86  */
87 
88 /**
89  * @brief LL PKC ECC Point Structure definition
90  */
91 typedef struct _ll_ecc_point
92 {
93  uint32_t X[ECC_U32_LENGTH]; /**< Specifies the point in x-axis */
94 
95  uint32_t Y[ECC_U32_LENGTH]; /**< Specifies the point in y-axis */
96 
98 
99 /**
100  * @brief LL PKC ECC P-256 Elliptic Curve Init Structure definition
101  */
102 typedef struct _ll_ecc_curve_init
103 {
104  uint32_t A[ECC_U32_LENGTH]; /**< Operand A array */
105  uint32_t B[ECC_U32_LENGTH]; /**< Operand B array */
106 
107  uint32_t P[ECC_U32_LENGTH]; /**< Prime number P array */
108  uint32_t PRSquare[ECC_U32_LENGTH]; /**< R^2 mod P, where R = 2^256 */
109  uint32_t ConstP; /**< Montgomery multiplication constant in prime field P, ConstP = 1 */
110 
111  uint32_t N[ECC_U32_LENGTH]; /**< Prime number N array */
112  uint32_t NRSquare[ECC_U32_LENGTH]; /**< R^2 mod N, where R = 2^256 */
113  uint32_t ConstN; /**< Montgomery multiplication constant in prime field N, ConstN = 0xee00bc4f */
114 
115  uint32_t H; /**< H */
116 
117  ll_ecc_point_t G; /**< ECC Point G */
118 
120 
121 /**
122  * @brief LL PKC Init Structure definition
123  */
124 typedef struct _ll_pkc_init
125 {
126  ll_ecc_curve_init_t *p_ecc_curve; /**< Specifies the pointer to elliptic curve description */
127 
128  uint32_t data_bits; /**< Specifies the Data size: 256 ~ 2048bits */
129 
131 
132 /** @} */
133 
134 /** @} */
135 
136 /**
137  * @defgroup PKC_LL_MACRO Defines
138  * @{
139  */
140 
141 /* Exported constants --------------------------------------------------------*/
142 /** @defgroup PKC_LL_Exported_Constants PKC Exported Constants
143  * @{
144  */
145 
146 /** @defgroup PKC_LL_EC_GET_FLAG Get Flags Defines
147  * @brief Flags defines which can be used with LL_PKC_ReadReg function
148  * @{
149  */
150 #define LL_PKC_WORKSTAT_BUSY PKC_STAT_BUSY /**< Busy flag */
151 /** @} */
152 
153 /** @defgroup PKC_LL_EC_IT IT Defines
154  * @brief Interrupt defines which can be used with LL_PKC_ReadReg and LL_PKC_WriteReg functions
155  * @{
156  */
157 #define LL_PKC_INTEN_DONE PKC_INT_EN_CPLT_INT_EN /**< Operation Done Interrupt source */
158 #define LL_PKC_INTEN_ERR PKC_INT_EN_ERR_INT_EN /**< Operation Error Interrupt source */
159 #define LL_PKC_INTEN_BAOVF PKC_INT_EN_BIAO_INT_EN /**< Big Integer Result Overflow Interrupt source */
160 /** @} */
161 
162 /** @defgroup PKC_LL_EC_BITS_LENGTH Bits Length
163  * @{
164  */
165 #define LL_PKC_BITS_LENGTH_MIN (256U) /**< Bits length min value */
166 #define LL_PKC_BITS_LENGTH_MAX (2048U) /**< Bits length max value */
167 #define LL_PKC_BIGMULTI_BITS_LENGTH_MAX (1024U) /**< Big number multiplication bits Length max value */
168 /** @} */
169 
170 /** @defgroup PKC_LL_EC_OPERATION_MODE Operation Mode
171  * @{
172  */
173 #define LL_PKC_operation_mode_MULTIPLY (0x00000000U) /**< Multiplication operation mode */
174 #define LL_PKC_operation_mode_INVERTION (1UL << PKC_SW_CTRL_MODE_POS) /**< Inversion operation mode */
175 #define LL_PKC_operation_mode_ADD (2UL << PKC_SW_CTRL_MODE_POS) /**< Addition operation mode */
176 #define LL_PKC_operation_mode_SUB (3UL << PKC_SW_CTRL_MODE_POS) /**< Subtraction operation mode */
177 #define LL_PKC_operation_mode_COMPARE (4UL << PKC_SW_CTRL_MODE_POS) /**< Comparison operation mode */
178 #define LL_PKC_operation_mode_LEFTSHIFT (5UL << PKC_SW_CTRL_MODE_POS) /**< Left Shift operation mode */
179 #define LL_PKC_operation_mode_BIGINTEGERMULTIPLY (6UL << PKC_SW_CTRL_MODE_POS) /**< Big Number Multiplication operation mode */
180 #define LL_PKC_operation_mode_BIGINTEGERADD (7UL << PKC_SW_CTRL_MODE_POS) /**< Big Number Addition operation mode */
181 /** @} */
182 
183 /** @defgroup PKC_LL_EC_DEFAULT_CONFIG InitStrcut default configuartion
184  * @{
185  */
186 
187 /**
188  * @brief LL PKC ECC Curve default configuretion.
189  */
190 #define LL_ECC_CURVE_DEFAULT_CONFIG LL_ECC_CURVE_SECP256R1_CONFIG
191 
192 /**
193  * @brief LL PKC ECC Curve SECP256R1 configuretion.
194  */
195 #define LL_ECC_CURVE_SECP256R1_CONFIG \
196 { \
197  .A = {0xFFFFFFFC, 0x00000004, 0x00000000, 0x00000000, 0x00000003, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFC}, \
198  .B = {0xDC30061D, 0x04874834, 0xE5A220AB, 0xF7212ED6, 0xACF005CD, 0x78843090, 0xD89CDF62, 0x29C4BDDF}, \
199  .P = {0xFFFFFFFF, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF}, \
200  .PRSquare = {0x00000004, 0xFFFFFFFD, 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFB, 0xFFFFFFFF, 0x00000000, 0x00000003}, \
201  .ConstP = 1, \
202  .N = {0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xBCE6FAAD, 0xA7179E84, 0xF3B9CAC2, 0xFC632551}, \
203  .NRSquare = {0x66E12D94, 0xF3D95620, 0x2845B239, 0x2B6BEC59, 0x4699799C, 0x49BD6FA6, 0x83244C95, 0xBE79EEA2}, \
204  .ConstN = 0xEE00BC4F, \
205  .H = 1, \
206  .G.X = {0x6B17D1F2, 0xE12C4247, 0xF8BCE6E5, 0x63A440F2, 0x77037D81, 0x2DEB33A0, 0xF4A13945, 0xD898C296}, \
207  .G.Y = {0x4FE342E2, 0xFE1A7F9B, 0x8EE7EB4A, 0x7C0F9E16, 0x2BCE3357, 0x6B315ECE, 0xCBB64068, 0x37BF51F5}, \
208 }
209 
210 /**
211  * @brief LL PKC ECC Curve SECP256K1 configuretion.
212  */
213 #define LL_ECC_CURVE_SECP256K1_CONFIG \
214 { \
215  .A = {0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000}, \
216  .B = {0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00001AB7}, \
217  .P = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFC2F}, \
218  .PRSquare = {0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000001, 0x000007A2, 0x000E90A1}, \
219  .ConstP = 0XD2253531, \
220  .N = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0xBAAEDCE6, 0xAF48A03B, 0xBFD25E8C, 0xD0364141}, \
221  .NRSquare = {0x9D671CD5, 0x81C69BC5, 0xE697F5E4, 0x5BCD07C6, 0x741496C2, 0x0E7CF878, 0x896CF214, 0x67D7D140}, \
222  .ConstN = 0X5588B13F, \
223  .H = 1, \
224  .G.X = {0x79BE667E, 0xF9DCBBAC, 0x55A06295, 0xCE870B07, 0x029BFCDB, 0x2DCE28D9, 0x59F2815B, 0x16F81798}, \
225  .G.Y = {0x483ADA77, 0x26A3C465, 0x5DA4FBFC, 0x0E1108A8, 0xFD17B448, 0xA6855419, 0x9C47D08F, 0xFB10D4B8}, \
226 }
227 
228 /** @} */
229 
230 /** @} */
231 
232 /* Exported macro ------------------------------------------------------------*/
233 /** @defgroup PKC_LL_Exported_Macros PKC Exported Macros
234  * @{
235  */
236 
237 /** @defgroup PKC_LL_EM_WRITE_READ Common Write and read registers Macros
238  * @{
239  */
240 
241 /**
242  * @brief Write a value in PKC register
243  * @param __INSTANCE__ PKC Instance
244  * @param __REG__ Register to be written
245  * @param __VALUE__ Value to be written in the register
246  * @retval None
247  */
248 #define LL_PKC_WriteReg(__INSTANCE__, __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))
249 
250 /**
251  * @brief Read a value in PKC register
252  * @param __INSTANCE__ PKC Instance
253  * @param __REG__ Register to be read
254  * @retval Register value
255  */
256 #define LL_PKC_ReadReg(__INSTANCE__, __REG__) READ_REG(__INSTANCE__->__REG__)
257 
258 /** @} */
259 
260 /** @} */
261 
262 /** @} */
263 
264 /* Exported functions --------------------------------------------------------*/
265 /** @defgroup PKC_LL_DRIVER_FUNCTIONS Functions
266  * @{
267  */
268 
269 /** @defgroup PKC_LL_EF_Configuration Configuration functions
270  * @{
271  */
272 
273 /**
274  * @brief Enable pkc.
275  *
276  * Register|BitsName
277  * ---------------|---------------
278  * CTRL | EN
279  *
280  * @param PKCx PKC instance
281  * @retval None
282  */
283 __STATIC_INLINE void ll_pkc_enable(pkc_regs_t *PKCx)
284 {
285  SET_BITS(PKCx->CTRL, PKC_CTRL_EN);
286 }
287 
288 /**
289  * @brief Disable pkc.
290  *
291  * Register|BitsName
292  * ---------------|---------------
293  * CTRL | EN
294  *
295  * @param PKCx PKC instance
296  * @retval None
297  */
298 __STATIC_INLINE void ll_pkc_disable(pkc_regs_t *PKCx)
299 {
300  CLEAR_BITS(PKCx->CTRL, PKC_CTRL_EN);
301 }
302 
303 /**
304  * @brief Indicate whether the pkc is enabled.
305  *
306  * Register|BitsName
307  * ---------------|---------------
308  * CTRL | EN
309  *
310  * @param PKCx PKC instance
311  * @retval State of bit (1 or 0).
312  */
313 __STATIC_INLINE uint32_t ll_pkc_is_enabled(pkc_regs_t *PKCx)
314 {
315  return (READ_BITS(PKCx->CTRL, PKC_CTRL_EN) == (PKC_CTRL_EN));
316 }
317 
318 /**
319  * @brief Enable pkc start in hardware mode.
320  *
321  * Register|BitsName
322  * ---------------|---------------
323  * CTRL | START
324  *
325  * @param PKCx PKC instance
326  * @retval None
327  */
328 __STATIC_INLINE void ll_pkc_enable_hardware_start(pkc_regs_t *PKCx)
329 {
330  SET_BITS(PKCx->CTRL, PKC_CTRL_START);
331 }
332 
333 /**
334  * @brief Disable pkc start in hardware mode.
335  *
336  * Register|BitsName
337  * ---------------|---------------
338  * CTRL | START
339  *
340  * @param PKCx PKC instance
341  * @retval None
342  */
343 __STATIC_INLINE void ll_pkc_disable_hardware_start(pkc_regs_t *PKCx)
344 {
345  CLEAR_BITS(PKCx->CTRL, PKC_CTRL_START);
346 }
347 
348 /**
349  * @brief Indicate whether the pkc start in hardware mode is enabled.
350  *
351  * Register|BitsName
352  * ---------------|---------------
353  * CTRL | START
354  *
355  * @param PKCx PKC instance
356  * @retval State of bit (1 or 0).
357  */
358 __STATIC_INLINE uint32_t ll_pkc_is_enabled_hardware_start(pkc_regs_t *PKCx)
359 {
360  return (READ_BITS(PKCx->CTRL, PKC_CTRL_START) == (PKC_CTRL_START));
361 }
362 
363 /**
364  * @brief Enable pkc software mode.
365  *
366  * Register|BitsName
367  * ---------------|---------------
368  * CTRL | SW_CTRL
369  *
370  * @param PKCx PKC instance
371  * @retval None
372  */
373 __STATIC_INLINE void ll_pkc_enable_software(pkc_regs_t *PKCx)
374 {
375  SET_BITS(PKCx->CTRL, PKC_CTRL_SW_CTRL);
376 }
377 
378 /**
379  * @brief Disable pkc software mode.
380  *
381  * Register|BitsName
382  * ---------------|---------------
383  * CTRL | SW_CTRL
384  *
385  * @param PKCx PKC instance
386  * @retval None
387  */
388 __STATIC_INLINE void ll_pkc_disable_software(pkc_regs_t *PKCx)
389 {
390  CLEAR_BITS(PKCx->CTRL, PKC_CTRL_SW_CTRL);
391 }
392 
393 /**
394  * @brief Indicate whether the pkc software mode is enabled.
395  *
396  * Register|BitsName
397  * ---------------|---------------
398  * CTRL | SW_CTRL
399  *
400  * @param PKCx PKC instance
401  * @retval State of bit (1 or 0).
402  */
403 __STATIC_INLINE uint32_t ll_pkc_is_enabled_software(pkc_regs_t *PKCx)
404 {
405  return (READ_BITS(PKCx->CTRL, PKC_CTRL_SW_CTRL) == (PKC_CTRL_SW_CTRL));
406 }
407 
408 /**
409  * @brief Enable pkc reset.
410  *
411  * Register|BitsName
412  * ---------------|---------------
413  * CTRL | RST
414  *
415  * @param PKCx PKC instance
416  * @retval None
417  */
418 __STATIC_INLINE void ll_pkc_enable_reset(pkc_regs_t *PKCx)
419 {
420  SET_BITS(PKCx->CTRL, PKC_CTRL_RST);
421 }
422 
423 /**
424  * @brief Disable pkc reset.
425  *
426  * Register|BitsName
427  * ---------------|---------------
428  * CTRL | RST
429  *
430  * @param PKCx PKC instance
431  * @retval None
432  */
433 __STATIC_INLINE void ll_pkc_disable_reset(pkc_regs_t *PKCx)
434 {
435  CLEAR_BITS(PKCx->CTRL, PKC_CTRL_RST);
436 }
437 
438 /**
439  * @brief Indicate whether the pkc reset is enabled.
440  *
441  * Register|BitsName
442  * ---------------|---------------
443  * CTRL | RST
444  *
445  * @param PKCx PKC instance
446  * @retval State of bit (1 or 0).
447  */
448 __STATIC_INLINE uint32_t ll_pkc_is_enabled_reset(pkc_regs_t *PKCx)
449 {
450  return (READ_BITS(PKCx->CTRL, PKC_CTRL_RST) == (PKC_CTRL_RST));
451 }
452 
453 /**
454  * @brief Set PKC parameter k pointer in pkc sram.
455  *
456  * Register|BitsName
457  * ---------------|---------------
458  * CFG0 | K_POINT
459  *
460  * @param PKCx PKC instance
461  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
462  * @retval None
463  */
464 __STATIC_INLINE void ll_pkc_set_k_pointer(pkc_regs_t *PKCx, uint32_t pointer)
465 {
466  MODIFY_REG(PKCx->CFG0, PKC_CFG0_K_POINT, pointer << PKC_CFG0_K_POINT_POS);
467 }
468 
469 /**
470  * @brief Get PKC parameter k pointer in pkc sram.
471  *
472  * Register|BitsName
473  * ---------------|---------------
474  * CFG0 | K_POINT
475  *
476  * @param PKCx PKC instance
477  * @retval Return value is between: 0 ~ 0x200
478  */
479 __STATIC_INLINE uint32_t ll_pkc_get_k_pointer(pkc_regs_t *PKCx)
480 {
481  return (READ_BITS(PKCx->CFG0, PKC_CFG0_K_POINT) >> PKC_CFG0_K_POINT_POS);
482 }
483 
484 /**
485  * @brief Set PKC parameter r pointer in pkc sram.
486  *
487  * Register|BitsName
488  * ---------------|---------------
489  * CFG0 | R_POINT
490  *
491  * @param PKCx PKC instance
492  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
493  * @retval None
494  */
495 __STATIC_INLINE void ll_pkc_set_r_pointer(pkc_regs_t *PKCx, uint32_t pointer)
496 {
497  MODIFY_REG(PKCx->CFG0, PKC_CFG0_R_POINT, pointer << PKC_CFG0_R_POINT_POS);
498 }
499 
500 /**
501  * @brief Get PKC parameter r pointer in pkc sram.
502  *
503  * Register|BitsName
504  * ---------------|---------------
505  * CFG0 | R_POINT
506  *
507  * @param PKCx PKC instance
508  * @retval Return value is between: 0 ~ 0x200
509  */
510 __STATIC_INLINE uint32_t ll_pkc_get_r_pointer(pkc_regs_t *PKCx)
511 {
512  return (READ_BITS(PKCx->CFG0, PKC_CFG0_R_POINT) >> PKC_CFG0_R_POINT_POS);
513 }
514 
515 /**
516  * @brief Set PKC parameter p pointer in pkc sram.
517  *
518  * Register|BitsName
519  * ---------------|---------------
520  * CFG1 | P_POINT
521  *
522  * @param PKCx PKC instance
523  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
524  * @retval None
525  */
526 __STATIC_INLINE void ll_pkc_set_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
527 {
528  MODIFY_REG(PKCx->CFG1, PKC_CFG1_P_POINT, pointer << PKC_CFG1_P_POINT_POS);
529 }
530 
531 /**
532  * @brief Get PKC parameter p pointer in pkc sram.
533  *
534  * Register|BitsName
535  * ---------------|---------------
536  * CFG1 | P_POINT
537  *
538  * @param PKCx PKC instance
539  * @retval Return value is between: 0 ~ 0x200
540  */
541 __STATIC_INLINE uint32_t ll_pkc_get_p_pointer(pkc_regs_t *PKCx)
542 {
543  return (READ_BITS(PKCx->CFG1, PKC_CFG1_P_POINT) >> PKC_CFG1_P_POINT_POS);
544 }
545 
546 /**
547  * @brief Set PKC parameter R^2 pointer in pkc sram.
548  *
549  * Register|BitsName
550  * ---------------|---------------
551  * CFG1 | R2_POINT
552  *
553  * @param PKCx PKC instance
554  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
555  * @retval None
556  */
557 __STATIC_INLINE void ll_pkc_set_rsq_pointer(pkc_regs_t *PKCx, uint32_t pointer)
558 {
559  MODIFY_REG(PKCx->CFG1, PKC_CFG1_R2_POINT, pointer << PKC_CFG1_R2_POINT_POS);
560 }
561 
562 /**
563  * @brief Get PKC parameter R^2 pointer in pkc sram.
564  *
565  * Register|BitsName
566  * ---------------|---------------
567  * CFG1 | R2_POINT
568  *
569  * @param PKCx PKC instance
570  * @retval Return value is between: 0 ~ 0x200
571  */
572 __STATIC_INLINE uint32_t ll_pkc_get_rsq_pointer(pkc_regs_t *PKCx)
573 {
574  return (READ_BITS(PKCx->CFG1, PKC_CFG1_R2_POINT) >> PKC_CFG1_R2_POINT_POS);
575 }
576 
577 /**
578  * @brief Set PKC parameter Gx pointer in pkc sram.
579  *
580  * Register|BitsName
581  * ---------------|---------------
582  * CFG2 | GX_POINT
583  *
584  * @param PKCx PKC instance
585  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
586  * @retval None
587  */
588 __STATIC_INLINE void ll_pkc_set_gx_pointer(pkc_regs_t *PKCx, uint32_t pointer)
589 {
590  MODIFY_REG(PKCx->CFG2, PKC_CFG2_GX_POINT, pointer << PKC_CFG2_GX_POINT_POS);
591 }
592 
593 /**
594  * @brief Get PKC parameter Gx pointer in pkc sram.
595  *
596  * Register|BitsName
597  * ---------------|---------------
598  * CFG2 | GX_POINT
599  *
600  * @param PKCx PKC instance
601  * @retval Return value is between: 0 ~ 0x200
602  */
603 __STATIC_INLINE uint32_t ll_pkc_get_gx_pointer(pkc_regs_t *PKCx)
604 {
605  return (READ_BITS(PKCx->CFG2, PKC_CFG2_GX_POINT) >> PKC_CFG2_GX_POINT_POS);
606 }
607 
608 /**
609  * @brief Set PKC parameter Gy pointer in pkc sram.
610  *
611  * Register|BitsName
612  * ---------------|---------------
613  * CFG2 | GY_POINT
614  *
615  * @param PKCx PKC instance
616  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
617  * @retval None
618  */
619 __STATIC_INLINE void ll_pkc_set_gy_pointer(pkc_regs_t *PKCx, uint32_t pointer)
620 {
621  MODIFY_REG(PKCx->CFG2, PKC_CFG2_GY_POINT, pointer << PKC_CFG2_GY_POINT_POS);
622 }
623 
624 /**
625  * @brief Get PKC parameter Gy pointer in pkc sram.
626  *
627  * Register|BitsName
628  * ---------------|---------------
629  * CFG2 | GY_POINT
630  *
631  * @param PKCx PKC instance
632  * @retval Return value is between: 0 ~ 0x200
633  */
634 __STATIC_INLINE uint32_t ll_pkc_get_gy_pointer(pkc_regs_t *PKCx)
635 {
636  return (READ_BITS(PKCx->CFG2, PKC_CFG2_GY_POINT) >> PKC_CFG2_GY_POINT_POS);
637 }
638 
639 /**
640  * @brief Set PKC parameter Gz pointer in pkc sram.
641  *
642  * Register|BitsName
643  * ---------------|---------------
644  * CFG3 | GZ_POINT
645  *
646  * @param PKCx PKC instance
647  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
648  * @retval None
649  */
650 __STATIC_INLINE void ll_pkc_set_gz_pointer(pkc_regs_t *PKCx, uint32_t pointer)
651 {
652  MODIFY_REG(PKCx->CFG3, PKC_CFG3_GZ_POINT, pointer << PKC_CFG3_GZ_POINT_POS);
653 }
654 
655 /**
656  * @brief Get PKC parameter Gz pointer in pkc sram.
657  *
658  * Register|BitsName
659  * ---------------|---------------
660  * CFG3 | GZ_POINT
661  *
662  * @param PKCx PKC instance
663  * @retval Return value is between: 0 ~ 0x200
664  */
665 __STATIC_INLINE uint32_t ll_pkc_get_gz_pointer(pkc_regs_t *PKCx)
666 {
667  return (READ_BITS(PKCx->CFG3, PKC_CFG3_GZ_POINT) >> PKC_CFG3_GZ_POINT_POS);
668 }
669 
670 /**
671  * @brief Set PKC parameter R0x pointer in pkc sram.
672  *
673  * Register|BitsName
674  * ---------------|---------------
675  * CFG3 | R0X_POINT
676  *
677  * @param PKCx PKC instance
678  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
679  * @retval None
680  */
681 __STATIC_INLINE void ll_pkc_set_r0x_pointer(pkc_regs_t *PKCx, uint32_t pointer)
682 {
683  MODIFY_REG(PKCx->CFG3, PKC_CFG3_R0X_POINT, pointer << PKC_CFG3_R0X_POINT_POS);
684 }
685 
686 /**
687  * @brief Get PKC parameter R0x pointer in pkc sram.
688  *
689  * Register|BitsName
690  * ---------------|---------------
691  * CFG3 | R0X_POINT
692  *
693  * @param PKCx PKC instance
694  * @retval Return value is between: 0 ~ 0x200
695  */
696 __STATIC_INLINE uint32_t ll_pkc_get_r0x_pointer(pkc_regs_t *PKCx)
697 {
698  return (READ_BITS(PKCx->CFG3, PKC_CFG3_R0X_POINT) >> PKC_CFG3_R0X_POINT_POS);
699 }
700 
701 /**
702  * @brief Set PKC parameter R0y pointer in pkc sram.
703  *
704  * Register|BitsName
705  * ---------------|---------------
706  * CFG4 | R0Y_POINT
707  *
708  * @param PKCx PKC instance
709  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
710  * @retval None
711  */
712 __STATIC_INLINE void ll_pkc_set_r0y_pointer(pkc_regs_t *PKCx, uint32_t pointer)
713 {
714  MODIFY_REG(PKCx->CFG4, PKC_CFG4_R0Y_POINT, pointer << PKC_CFG4_R0Y_POINT_POS);
715 }
716 
717 /**
718  * @brief Get PKC parameter R0y pointer in pkc sram.
719  *
720  * Register|BitsName
721  * ---------------|---------------
722  * CFG4 | R0Y_POINT
723  *
724  * @param PKCx PKC instance
725  * @retval Return value is between: 0 ~ 0x200
726  */
727 __STATIC_INLINE uint32_t ll_pkc_get_r0y_pointer(pkc_regs_t *PKCx)
728 {
729  return (READ_BITS(PKCx->CFG4, PKC_CFG4_R0Y_POINT) >> PKC_CFG4_R0Y_POINT_POS);
730 }
731 
732 /**
733  * @brief Set PKC parameter R0z pointer in pkc sram.
734  *
735  * Register|BitsName
736  * ---------------|---------------
737  * CFG4 | R0Z_POINT
738  *
739  * @param PKCx PKC instance
740  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
741  * @retval None
742  */
743 __STATIC_INLINE void ll_pkc_set_r0z_pointer(pkc_regs_t *PKCx, uint32_t pointer)
744 {
745  MODIFY_REG(PKCx->CFG4, PKC_CFG4_R0Z_POINT, pointer << PKC_CFG4_R0Z_POINT_POS);
746 }
747 
748 /**
749  * @brief Get PKC parameter R0z pointer in pkc sram.
750  *
751  * Register|BitsName
752  * ---------------|---------------
753  * CFG4 | R0Z_POINT
754  *
755  * @param PKCx PKC instance
756  * @retval Return value is between: 0 ~ 0x200
757  */
758 __STATIC_INLINE uint32_t ll_pkc_get_r0z_pointer(pkc_regs_t *PKCx)
759 {
760  return (READ_BITS(PKCx->CFG4, PKC_CFG4_R0Z_POINT) >> PKC_CFG4_R0Z_POINT_POS);
761 }
762 
763 /**
764  * @brief Set PKC parameter R1x pointer in pkc sram.
765  *
766  * Register|BitsName
767  * ---------------|---------------
768  * CFG5 | R1X_POINT
769  *
770  * @param PKCx PKC instance
771  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
772  * @retval None
773  */
774 __STATIC_INLINE void ll_pkc_set_r1x_pointer(pkc_regs_t *PKCx, uint32_t pointer)
775 {
776  MODIFY_REG(PKCx->CFG5, PKC_CFG5_R1X_POINT, pointer << PKC_CFG5_R1X_POINT_POS);
777 }
778 
779 /**
780  * @brief Get PKC parameter R1x pointer in pkc sram.
781  *
782  * Register|BitsName
783  * ---------------|---------------
784  * CFG5 | R1X_POINT
785  *
786  * @param PKCx PKC instance
787  * @retval Return value is between: 0 ~ 0x200
788  */
789 __STATIC_INLINE uint32_t ll_pkc_get_r1x_pointer(pkc_regs_t *PKCx)
790 {
791  return (READ_BITS(PKCx->CFG5, PKC_CFG5_R1X_POINT) >> PKC_CFG5_R1X_POINT_POS);
792 }
793 
794 /**
795  * @brief Set PKC parameter R1y pointer in pkc sram.
796  *
797  * Register|BitsName
798  * ---------------|---------------
799  * CFG5 | R1Y_POINT
800  *
801  * @param PKCx PKC instance
802  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
803  * @retval None
804  */
805 __STATIC_INLINE void ll_pkc_set_r1y_pointer(pkc_regs_t *PKCx, uint32_t pointer)
806 {
807  MODIFY_REG(PKCx->CFG5, PKC_CFG5_R1Y_POINT, pointer << PKC_CFG5_R1Y_POINT_POS);
808 }
809 
810 /**
811  * @brief Get PKC parameter R1y pointer in pkc sram.
812  *
813  * Register|BitsName
814  * ---------------|---------------
815  * CFG5 | R1Y_POINT
816  *
817  * @param PKCx PKC instance
818  * @retval Return value is between: 0 ~ 0x200
819  */
820 __STATIC_INLINE uint32_t ll_pkc_get_r1y_pointer(pkc_regs_t *PKCx)
821 {
822  return (READ_BITS(PKCx->CFG5, PKC_CFG5_R1Y_POINT) >> PKC_CFG5_R1Y_POINT_POS);
823 }
824 
825 /**
826  * @brief Set PKC parameter R1z pointer in pkc sram.
827  *
828  * Register|BitsName
829  * ---------------|---------------
830  * CFG6 | R1Z_POINT
831  *
832  * @param PKCx PKC instance
833  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
834  * @retval None
835  */
836 __STATIC_INLINE void ll_pkc_set_r1z_pointer(pkc_regs_t *PKCx, uint32_t pointer)
837 {
838  MODIFY_REG(PKCx->CFG6, PKC_CFG6_R1Z_POINT, pointer << PKC_CFG6_R1Z_POINT_POS);
839 }
840 
841 /**
842  * @brief Get PKC parameter R1z pointer in pkc sram.
843  *
844  * Register|BitsName
845  * ---------------|---------------
846  * CFG6 | R1Z_POINT
847  *
848  * @param PKCx PKC instance
849  * @retval Return value is between: 0 ~ 0x200
850  */
851 __STATIC_INLINE uint32_t ll_pkc_get_r1z_pointer(pkc_regs_t *PKCx)
852 {
853  return (READ_BITS(PKCx->CFG6, PKC_CFG6_R1Z_POINT) >> PKC_CFG6_R1Z_POINT_POS);
854 }
855 
856 /**
857  * @brief Set PKC parameter Tmp1 pointer in pkc sram.
858  *
859  * Register|BitsName
860  * ---------------|---------------
861  * CFG6 | TEMP1_POINT
862  *
863  * @param PKCx PKC instance
864  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
865  * @retval None
866  */
867 __STATIC_INLINE void ll_pkc_set_tmp1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
868 {
869  MODIFY_REG(PKCx->CFG6, PKC_CFG6_TEMP1_POINT, pointer << PKC_CFG6_TEMP1_POINT_POS);
870 }
871 
872 /**
873  * @brief Get PKC parameter Tmp1 pointer in pkc sram.
874  *
875  * Register|BitsName
876  * ---------------|---------------
877  * CFG6 | TEMP1_POINT
878  *
879  * @param PKCx PKC instance
880  * @retval Return value is between: 0 ~ 0x200
881  */
882 __STATIC_INLINE uint32_t ll_pkc_get_tmp1_pointer(pkc_regs_t *PKCx)
883 {
884  return (READ_BITS(PKCx->CFG6, PKC_CFG6_TEMP1_POINT) >> PKC_CFG6_TEMP1_POINT_POS);
885 }
886 
887 /**
888  * @brief Set PKC parameter Tmp2 pointer in pkc sram.
889  *
890  * Register|BitsName
891  * ---------------|---------------
892  * CFG7 | TEMP2_POINT
893  *
894  * @param PKCx PKC instance
895  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
896  * @retval None
897  */
898 __STATIC_INLINE void ll_pkc_set_tmp2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
899 {
900  MODIFY_REG(PKCx->CFG7, PKC_CFG7_TEMP2_POINT, pointer << PKC_CFG7_TEMP2_POINT_POS);
901 }
902 
903 /**
904  * @brief Get PKC parameter Tmp2 pointer in pkc sram.
905  *
906  * Register|BitsName
907  * ---------------|---------------
908  * CFG7 | TEMP2_POINT
909  *
910  * @param PKCx PKC instance
911  * @retval Return value is between: 0 ~ 0x200
912  */
913 __STATIC_INLINE uint32_t ll_pkc_get_tmp2_pointer(pkc_regs_t *PKCx)
914 {
915  return (READ_BITS(PKCx->CFG7, PKC_CFG7_TEMP2_POINT) >> PKC_CFG7_TEMP2_POINT_POS);
916 }
917 
918 /**
919  * @brief Set PKC parameter Tmp3 pointer in pkc sram.
920  *
921  * Register|BitsName
922  * ---------------|---------------
923  * CFG7 | TEMP3_POINT
924  *
925  * @param PKCx PKC instance
926  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
927  * @retval None
928  */
929 __STATIC_INLINE void ll_pkc_set_tmp3_pointer(pkc_regs_t *PKCx, uint32_t pointer)
930 {
931  MODIFY_REG(PKCx->CFG7, PKC_CFG7_TEMP3_POINT, pointer << PKC_CFG7_TEMP3_POINT_POS);
932 }
933 
934 /**
935  * @brief Get PKC parameter Tmp3 pointer in pkc sram.
936  *
937  * Register|BitsName
938  * ---------------|---------------
939  * CFG7 | TEMP3_POINT
940  *
941  * @param PKCx PKC instance
942  * @retval Return value is between: 0 ~ 0x200
943  */
944 __STATIC_INLINE uint32_t ll_pkc_get_tmp3_pointer(pkc_regs_t *PKCx)
945 {
946  return (READ_BITS(PKCx->CFG7, PKC_CFG7_TEMP3_POINT) >> PKC_CFG7_TEMP3_POINT_POS);
947 }
948 
949 /**
950  * @brief Set PKC parameter Tmp4 pointer in pkc sram.
951  *
952  * Register|BitsName
953  * ---------------|---------------
954  * CFG8 | TEMP4_POINT
955  *
956  * @param PKCx PKC instance
957  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
958  * @retval None
959  */
960 __STATIC_INLINE void ll_pkc_set_tmp4_pointer(pkc_regs_t *PKCx, uint32_t pointer)
961 {
962  MODIFY_REG(PKCx->CFG8, PKC_CFG8_TEMP4_POINT, pointer << PKC_CFG8_TEMP4_POINT_POS);
963 }
964 
965 /**
966  * @brief Get PKC parameter Tmp4 pointer in pkc sram.
967  *
968  * Register|BitsName
969  * ---------------|---------------
970  * CFG8 | TEMP4_POINT
971  *
972  * @param PKCx PKC instance
973  * @retval Return value is between: 0 ~ 0x200
974  */
975 __STATIC_INLINE uint32_t ll_pkc_get_tmp4_pointer(pkc_regs_t *PKCx)
976 {
977  return (READ_BITS(PKCx->CFG8, PKC_CFG8_TEMP4_POINT) >> PKC_CFG8_TEMP4_POINT_POS);
978 }
979 
980 /**
981  * @brief Set PKC parameter Tmp5 pointer in pkc sram.
982  *
983  * Register|BitsName
984  * ---------------|---------------
985  * CFG8 | TEMP5_POINT
986  *
987  * @param PKCx PKC instance
988  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
989  * @retval None
990  */
991 __STATIC_INLINE void ll_pkc_set_tmp5_pointer(pkc_regs_t *PKCx, uint32_t pointer)
992 {
993  MODIFY_REG(PKCx->CFG8, PKC_CFG8_TEMP5_POINT, pointer << PKC_CFG8_TEMP5_POINT_POS);
994 }
995 
996 /**
997  * @brief Get PKC parameter Tmp5 pointer in pkc sram.
998  *
999  * Register|BitsName
1000  * ---------------|---------------
1001  * CFG8 | TEMP5_POINT
1002  *
1003  * @param PKCx PKC instance
1004  * @retval Return value is between: 0 ~ 0x200
1005  */
1006 __STATIC_INLINE uint32_t ll_pkc_get_tmp5_pointer(pkc_regs_t *PKCx)
1007 {
1008  return (READ_BITS(PKCx->CFG8, PKC_CFG8_TEMP5_POINT) >> PKC_CFG8_TEMP5_POINT_POS);
1009 }
1010 
1011 /**
1012  * @brief Set PKC parameter Tmp6 pointer in pkc sram.
1013  *
1014  * Register|BitsName
1015  * ---------------|---------------
1016  * CFG9 | TEMP6_POINT
1017  *
1018  * @param PKCx PKC instance
1019  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1020  * @retval None
1021  */
1022 __STATIC_INLINE void ll_pkc_set_tmp6_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1023 {
1024  MODIFY_REG(PKCx->CFG9, PKC_CFG9_TEMP6_POINT, pointer << PKC_CFG9_TEMP6_POINT_POS);
1025 }
1026 
1027 /**
1028  * @brief Get PKC parameter Tmp6 pointer in pkc sram.
1029  *
1030  * Register|BitsName
1031  * ---------------|---------------
1032  * CFG9 | TEMP6_POINT
1033  *
1034  * @param PKCx PKC instance
1035  * @retval Return value is between: 0 ~ 0x200
1036  */
1037 __STATIC_INLINE uint32_t ll_pkc_get_tmp6_pointer(pkc_regs_t *PKCx)
1038 {
1039  return (READ_BITS(PKCx->CFG9, PKC_CFG9_TEMP6_POINT) >> PKC_CFG9_TEMP6_POINT_POS);
1040 }
1041 
1042 /**
1043  * @brief Set PKC parameter Constant1 pointer in pkc sram.
1044  *
1045  * Register|BitsName
1046  * ---------------|---------------
1047  * CFG9 | CONT1_POINT
1048  *
1049  * @param PKCx PKC instance
1050  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1051  * @retval None
1052  */
1053 __STATIC_INLINE void ll_pkc_set_constant1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1054 {
1055  MODIFY_REG(PKCx->CFG9, PKC_CFG9_CONT1_POINT, pointer << PKC_CFG9_CONT1_POINT_POS);
1056 }
1057 
1058 /**
1059  * @brief Get PKC parameter Constant1 pointer in pkc sram.
1060  *
1061  * Register|BitsName
1062  * ---------------|---------------
1063  * CFG9 | CONT1_POINT
1064  *
1065  * @param PKCx PKC instance
1066  * @retval Return value is between: 0 ~ 0x200
1067  */
1068 __STATIC_INLINE uint32_t ll_pkc_get_constant1_pointer(pkc_regs_t *PKCx)
1069 {
1070  return (READ_BITS(PKCx->CFG9, PKC_CFG9_CONT1_POINT) >> PKC_CFG9_CONT1_POINT_POS);
1071 }
1072 
1073 /**
1074  * @brief Set PKC parameter X1 pointer in pkc sram.
1075  *
1076  * Register|BitsName
1077  * ---------------|---------------
1078  * CFG10 | X1_POINT
1079  *
1080  * @param PKCx PKC instance
1081  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1082  * @retval None
1083  */
1084 __STATIC_INLINE void ll_pkc_set_x1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1085 {
1086  MODIFY_REG(PKCx->CFG10, PKC_CFG10_X1_POINT, pointer << PKC_CFG10_X1_POINT_POS);
1087 }
1088 
1089 /**
1090  * @brief Get PKC parameter X1 pointer in pkc sram.
1091  *
1092  * Register|BitsName
1093  * ---------------|---------------
1094  * CFG10 | X1_POINT
1095  *
1096  * @param PKCx PKC instance
1097  * @retval Return value is between: 0 ~ 0x200
1098  */
1099 __STATIC_INLINE uint32_t ll_pkc_get_x1_pointer(pkc_regs_t *PKCx)
1100 {
1101  return (READ_BITS(PKCx->CFG10, PKC_CFG10_X1_POINT) >> PKC_CFG10_X1_POINT_POS);
1102 }
1103 
1104 /**
1105  * @brief Set PKC parameter X2 pointer in pkc sram.
1106  *
1107  * Register|BitsName
1108  * ---------------|---------------
1109  * CFG10 | X2_POINT
1110  *
1111  * @param PKCx PKC instance
1112  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1113  * @retval None
1114  */
1115 __STATIC_INLINE void ll_pkc_set_x2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1116 {
1117  MODIFY_REG(PKCx->CFG10, PKC_CFG10_X2_POINT, pointer << PKC_CFG10_X2_POINT_POS);
1118 }
1119 
1120 /**
1121  * @brief Get PKC parameter X2 pointer in pkc sram.
1122  *
1123  * Register|BitsName
1124  * ---------------|---------------
1125  * CFG10 | X2_POINT
1126  *
1127  * @param PKCx PKC instance
1128  * @retval Return value is between: 0 ~ 0x200
1129  */
1130 __STATIC_INLINE uint32_t ll_pkc_get_x2_pointer(pkc_regs_t *PKCx)
1131 {
1132  return (READ_BITS(PKCx->CFG10, PKC_CFG10_X2_POINT) >> PKC_CFG10_X2_POINT_POS);
1133 }
1134 
1135 /**
1136  * @brief Set PKC parameter MITmp pointer in pkc sram.
1137  *
1138  * Register|BitsName
1139  * ---------------|---------------
1140  * CFG11 | MIT_POINT
1141  *
1142  * @param PKCx PKC instance
1143  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1144  * @retval None
1145  */
1146 __STATIC_INLINE void ll_pkc_set_mitmp_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1147 {
1148  MODIFY_REG(PKCx->CFG11, PKC_CFG11_MIT_POINT, pointer << PKC_CFG11_MIT_POINT_POS);
1149 }
1150 
1151 /**
1152  * @brief Get PKC parameter MITmp pointer in pkc sram.
1153  *
1154  * Register|BitsName
1155  * ---------------|---------------
1156  * CFG11 | MIT_POINT
1157  *
1158  * @param PKCx PKC instance
1159  * @retval Return value is between: 0 ~ 0x200
1160  */
1161 __STATIC_INLINE uint32_t ll_pkc_get_mitmp_pointer(pkc_regs_t *PKCx)
1162 {
1163  return (READ_BITS(PKCx->CFG11, PKC_CFG11_MIT_POINT) >> PKC_CFG11_MIT_POINT_POS);
1164 }
1165 
1166 /**
1167  * @brief Set PKC parameter TmpK pointer in pkc sram.
1168  *
1169  * Register|BitsName
1170  * ---------------|---------------
1171  * CFG11 | KT_POINT
1172  *
1173  * @param PKCx PKC instance
1174  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1175  * @retval None
1176  */
1177 __STATIC_INLINE void ll_pkc_set_tmpk_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1178 {
1179  MODIFY_REG(PKCx->CFG11, PKC_CFG11_KT_POINT, pointer << PKC_CFG11_KT_POINT_POS);
1180 }
1181 
1182 /**
1183  * @brief Get PKC parameter TmpK pointer in pkc sram.
1184  *
1185  * Register|BitsName
1186  * ---------------|---------------
1187  * CFG11 | KT_POINT
1188  *
1189  * @param PKCx PKC instance
1190  * @retval Return value is between: 0 ~ 0x200
1191  */
1192 __STATIC_INLINE uint32_t ll_pkc_get_tmpk_pointer(pkc_regs_t *PKCx)
1193 {
1194  return (READ_BITS(PKCx->CFG11, PKC_CFG11_KT_POINT) >> PKC_CFG11_KT_POINT_POS);
1195 }
1196 
1197 /**
1198  * @brief Set ECC parameter A pointer in pkc sram.
1199  *
1200  * Register|BitsName
1201  * ---------------|---------------
1202  * CFG12 | A_POINT
1203  *
1204  * @param PKCx PKC instance
1205  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1206  * @retval None
1207  */
1208 __STATIC_INLINE void ll_pkc_set_ecc_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1209 {
1210  MODIFY_REG(PKCx->CFG12, PKC_CFG12_A_POINT, pointer << PKC_CFG12_A_POINT_POS);
1211 }
1212 
1213 /**
1214  * @brief Get ECC parameter A pointer in pkc sram.
1215  *
1216  * Register|BitsName
1217  * ---------------|---------------
1218  * CFG12 | A_POINT
1219  *
1220  * @param PKCx PKC instance
1221  * @retval Return value is between: 0 ~ 0x200
1222  */
1223 __STATIC_INLINE uint32_t ll_pkc_get_ecc_a_pointer(pkc_regs_t *PKCx)
1224 {
1225  return (READ_BITS(PKCx->CFG12, PKC_CFG12_A_POINT) >> PKC_CFG12_A_POINT_POS);
1226 }
1227 
1228 /**
1229  * @brief Set ECC parameter B pointer in pkc sram.
1230  *
1231  * Register|BitsName
1232  * ---------------|---------------
1233  * CFG12 | B_POINT
1234  *
1235  * @param PKCx PKC instance
1236  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1237  * @retval None
1238  */
1239 __STATIC_INLINE void ll_pkc_set_ecc_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1240 {
1241  MODIFY_REG(PKCx->CFG12, PKC_CFG12_B_POINT, pointer << PKC_CFG12_B_POINT_POS);
1242 }
1243 
1244 /**
1245  * @brief Get ECC parameter B pointer in pkc sram.
1246  *
1247  * Register|BitsName
1248  * ---------------|---------------
1249  * CFG12 | B_POINT
1250  *
1251  * @param PKCx PKC instance
1252  * @retval Return value is between: 0 ~ 0x200
1253  */
1254 __STATIC_INLINE uint32_t ll_pkc_get_ecc_b_pointer(pkc_regs_t *PKCx)
1255 {
1256  return (READ_BITS(PKCx->CFG12, PKC_CFG12_B_POINT) >> PKC_CFG12_B_POINT_POS);
1257 }
1258 
1259 /**
1260  * @brief Set constant value for montgomery multiply in pkc sram.
1261  *
1262  * Register|BitsName
1263  * ---------------|---------------
1264  * CFG13 | CONSTP
1265  *
1266  * @param PKCx PKC instance
1267  * @param ConstP This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1268  * @retval None
1269  */
1270 __STATIC_INLINE void ll_pkc_set_constp(pkc_regs_t *PKCx, uint32_t ConstP)
1271 {
1272  WRITE_REG(PKCx->CFG13, ConstP);
1273 }
1274 
1275 /**
1276  * @brief Get constant value for montgomery multiply in pkc sram.
1277  *
1278  * Register|BitsName
1279  * ---------------|---------------
1280  * CFG13 | CONSTP
1281  *
1282  * @param PKCx PKC instance
1283  * @retval Return value is between: 0 ~ 0x200
1284  */
1285 __STATIC_INLINE uint32_t ll_pkc_get_constp(pkc_regs_t *PKCx)
1286 {
1287  return (READ_REG(PKCx->CFG13));
1288 }
1289 
1290 /**
1291  * @brief Enable pkc start in software mode.
1292  *
1293  * Register|BitsName
1294  * ---------------|---------------
1295  * SW_CTRL | START
1296  *
1297  * @param PKCx PKC instance
1298  * @retval None
1299  */
1300 __STATIC_INLINE void ll_pkc_enable_software_start(pkc_regs_t *PKCx)
1301 {
1302  SET_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_START);
1303 }
1304 
1305 /**
1306  * @brief Disable pkc start in software mode.
1307  *
1308  * Register|BitsName
1309  * ---------------|---------------
1310  * SW_CTRL | START
1311  *
1312  * @param PKCx PKC instance
1313  * @retval None
1314  */
1315 __STATIC_INLINE void ll_pkc_disable_software_start(pkc_regs_t *PKCx)
1316 {
1317  CLEAR_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_START);
1318 }
1319 
1320 /**
1321  * @brief Indicate whether the pkc start in software mode is enabled.
1322  *
1323  * Register|BitsName
1324  * ---------------|---------------
1325  * SW_CTRL | START
1326  *
1327  * @param PKCx PKC instance
1328  * @retval State of bit (1 or 0).
1329  */
1330 __STATIC_INLINE uint32_t ll_pkc_is_enabled_software_start(pkc_regs_t *PKCx)
1331 {
1332  return (READ_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_START) == (PKC_SW_CTRL_START));
1333 }
1334 
1335 /**
1336  * @brief Set operation mode in software mode.
1337  *
1338  * Register|BitsName
1339  * ---------------|---------------
1340  * SW_CTRL | MODE
1341  *
1342  * @param PKCx PKC instance
1343  * @param operation_mode This parameter can be one of the following values:
1344  * @arg @ref LL_PKC_operation_mode_MULTIPLY
1345  * @arg @ref LL_PKC_operation_mode_INVERTION
1346  * @arg @ref LL_PKC_operation_mode_ADD
1347  * @arg @ref LL_PKC_operation_mode_SUB
1348  * @arg @ref LL_PKC_operation_mode_COMPARE
1349  * @arg @ref LL_PKC_operation_mode_LEFTSHIFT
1350  * @arg @ref LL_PKC_operation_mode_BIGINTEGERMULTIPLY
1351  * @arg @ref LL_PKC_operation_mode_BIGINTEGERADD
1352  * @retval None
1353  */
1354 __STATIC_INLINE void ll_pkc_set_operation_mode(pkc_regs_t *PKCx, uint32_t operation_mode)
1355 {
1356  MODIFY_REG(PKCx->SW_CTRL, PKC_SW_CTRL_MODE, operation_mode);
1357 }
1358 
1359 /**
1360  * @brief Get operation mode in software mode.
1361  *
1362  * Register|BitsName
1363  * ---------------|---------------
1364  * SW_CTRL | MODE
1365  *
1366  * @param PKCx PKC instance
1367  * @retval Return value can be one of the following values:
1368  * @arg @ref LL_PKC_operation_mode_MULTIPLY
1369  * @arg @ref LL_PKC_operation_mode_INVERTION
1370  * @arg @ref LL_PKC_operation_mode_ADD
1371  * @arg @ref LL_PKC_operation_mode_SUB
1372  * @arg @ref LL_PKC_operation_mode_COMPARE
1373  * @arg @ref LL_PKC_operation_mode_LEFTSHIFT
1374  * @arg @ref LL_PKC_operation_mode_BIGINTEGERMULTIPLY
1375  * @arg @ref LL_PKC_operation_mode_BIGINTEGERADD
1376  */
1377 __STATIC_INLINE uint32_t ll_pkc_get_operation_mode(pkc_regs_t *PKCx)
1378 {
1379  return (READ_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_MODE));
1380 }
1381 
1382 /**
1383  * @brief Enable Dummy Multi in software mode.
1384  *
1385  * Register|BitsName
1386  * ---------------|---------------
1387  * SW_CTRL | DM_EN
1388  *
1389  * @param PKCx PKC instance
1390  * @retval None
1391  */
1392 __STATIC_INLINE void ll_pkc_enable_dummy_multi(pkc_regs_t *PKCx)
1393 {
1394  SET_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_DM_EN);
1395 }
1396 
1397 /**
1398  * @brief Disable Dummy Multi in software mode.
1399  *
1400  * Register|BitsName
1401  * ---------------|---------------
1402  * SW_CTRL | DM_EN
1403  *
1404  * @param PKCx PKC instance
1405  * @retval None
1406  */
1407 __STATIC_INLINE void ll_pkc_disable_dummy_multi(pkc_regs_t *PKCx)
1408 {
1409  CLEAR_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_DM_EN);
1410 }
1411 
1412 /**
1413  * @brief Indicate whether the Dummy Multi in software mode is enabled.
1414  *
1415  * Register|BitsName
1416  * ---------------|---------------
1417  * SW_CTRL | DM_EN
1418  *
1419  * @param PKCx PKC instance
1420  * @retval State of bit (1 or 0).
1421  */
1422 __STATIC_INLINE uint32_t ll_pkc_is_enabled_dummy_multi(pkc_regs_t *PKCx)
1423 {
1424  return (READ_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_DM_EN) == (PKC_SW_CTRL_DM_EN));
1425 }
1426 
1427 /**
1428  * @brief Enable Random Clock Gating in software mode.
1429  *
1430  * Register|BitsName
1431  * ---------------|---------------
1432  * SW_CTRL | RANDEN
1433  *
1434  * @param PKCx PKC instance
1435  * @retval None
1436  */
1437 __STATIC_INLINE void ll_pkc_enable_random_clock_gating(pkc_regs_t *PKCx)
1438 {
1439  SET_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_RCG_EN);
1440 }
1441 
1442 /**
1443  * @brief Disable Random Clock Gating in software mode.
1444  *
1445  * Register|BitsName
1446  * ---------------|---------------
1447  * SW_CTRL | RANDEN
1448  *
1449  * @param PKCx PKC instance
1450  * @retval None
1451  */
1452 __STATIC_INLINE void ll_pkc_disable_random_clock_gating(pkc_regs_t *PKCx)
1453 {
1454  CLEAR_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_RCG_EN);
1455 }
1456 
1457 /**
1458  * @brief Indicate whether the Random Clock Gating in software mode is enabled.
1459  *
1460  * Register|BitsName
1461  * ---------------|---------------
1462  * SW_CTRL | RANDEN
1463  *
1464  * @param PKCx PKC instance
1465  * @retval State of bit (1 or 0).
1466  */
1467 __STATIC_INLINE uint32_t ll_pkc_is_enabled_random_clock_gating(pkc_regs_t *PKCx)
1468 {
1469  return (READ_BITS(PKCx->SW_CTRL, PKC_SW_CTRL_RCG_EN) == (PKC_SW_CTRL_RCG_EN));
1470 }
1471 
1472 /**
1473  * @brief Set modular multiplication parameter A pointer in pkc sram.
1474  *
1475  * Register|BitsName
1476  * ---------------|---------------
1477  * SW_CFG0 | MMA_POINT
1478  *
1479  * @param PKCx PKC instance
1480  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1481  * @retval None
1482  */
1483 __STATIC_INLINE void ll_pkc_set_mm_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1484 {
1485  MODIFY_REG(PKCx->SW_CFG0, PKC_SW_CFG0_MMA_POINT, pointer << PKC_SW_CFG0_MMA_POINT_POS);
1486 }
1487 
1488 /**
1489  * @brief Get modular multiplication parameter A pointer in pkc sram.
1490  *
1491  * Register|BitsName
1492  * ---------------|---------------
1493  * SW_CFG0 | MMA_POINT
1494  *
1495  * @param PKCx PKC instance
1496  * @retval Return value is between: 0 ~ 0x200
1497  */
1498 __STATIC_INLINE uint32_t ll_pkc_get_mm_a_pointer(pkc_regs_t *PKCx)
1499 {
1500  return (READ_BITS(PKCx->SW_CFG0, PKC_SW_CFG0_MMA_POINT) >> PKC_SW_CFG0_MMA_POINT_POS);
1501 }
1502 
1503 /**
1504  * @brief Set modular multiplication parameter B pointer in pkc sram.
1505  *
1506  * Register|BitsName
1507  * ---------------|---------------
1508  * SW_CFG0 | MMB_POINT
1509  *
1510  * @param PKCx PKC instance
1511  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1512  * @retval None
1513  */
1514 __STATIC_INLINE void ll_pkc_set_mm_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1515 {
1516  MODIFY_REG(PKCx->SW_CFG0, PKC_SW_CFG0_MMB_POINT, pointer << PKC_SW_CFG0_MMB_POINT_POS);
1517 }
1518 
1519 /**
1520  * @brief Get modular multiplication parameter B pointer in pkc sram.
1521  *
1522  * Register|BitsName
1523  * ---------------|---------------
1524  * SW_CFG0 | MMB_POINT
1525  *
1526  * @param PKCx PKC instance
1527  * @retval Return value is between: 0 ~ 0x200
1528  */
1529 __STATIC_INLINE uint32_t ll_pkc_get_mm_b_pointer(pkc_regs_t *PKCx)
1530 {
1531  return (READ_BITS(PKCx->SW_CFG0, PKC_SW_CFG0_MMB_POINT) >> PKC_SW_CFG0_MMB_POINT_POS);
1532 }
1533 
1534 /**
1535  * @brief Set modular multiplication parameter P pointer in pkc sram.
1536  *
1537  * Register|BitsName
1538  * ---------------|---------------
1539  * SW_CFG1 | MMP_POINT
1540  *
1541  * @param PKCx PKC instance
1542  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1543  * @retval None
1544  */
1545 __STATIC_INLINE void ll_pkc_set_mm_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1546 {
1547  MODIFY_REG(PKCx->SW_CFG1, PKC_SW_CFG1_MMP_POINT, pointer << PKC_SW_CFG1_MMP_POINT_POS);
1548 }
1549 
1550 /**
1551  * @brief Get modular multiplication parameter P pointer in pkc sram.
1552  *
1553  * Register|BitsName
1554  * ---------------|---------------
1555  * SW_CFG1 | MMP_POINT
1556  *
1557  * @param PKCx PKC instance
1558  * @retval Return value is between: 0 ~ 0x200
1559  */
1560 __STATIC_INLINE uint32_t ll_pkc_get_mm_p_pointer(pkc_regs_t *PKCx)
1561 {
1562  return (READ_BITS(PKCx->SW_CFG1, PKC_SW_CFG1_MMP_POINT) >> PKC_SW_CFG1_MMP_POINT_POS);
1563 }
1564 
1565 /**
1566  * @brief Set modular multiplication parameter C pointer in pkc sram.
1567  *
1568  * Register|BitsName
1569  * ---------------|---------------
1570  * SW_CFG1 | MMC_POINT
1571  *
1572  * @param PKCx PKC instance
1573  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1574  * @retval None
1575  */
1576 __STATIC_INLINE void ll_pkc_set_mm_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1577 {
1578  MODIFY_REG(PKCx->SW_CFG1, PKC_SW_CFG1_MMC_POINT, pointer << PKC_SW_CFG1_MMC_POINT_POS);
1579 }
1580 
1581 /**
1582  * @brief Get modular multiplication parameter C pointer in pkc sram.
1583  *
1584  * Register|BitsName
1585  * ---------------|---------------
1586  * SW_CFG1 | MMC_POINT
1587  *
1588  * @param PKCx PKC instance
1589  * @retval Return value is between: 0 ~ 0x200
1590  */
1591 __STATIC_INLINE uint32_t ll_pkc_get_mm_c_pointer(pkc_regs_t *PKCx)
1592 {
1593  return (READ_BITS(PKCx->SW_CFG1, PKC_SW_CFG1_MMC_POINT) >> PKC_SW_CFG1_MMC_POINT_POS);
1594 }
1595 
1596 /**
1597  * @brief Set modular add/sub parameter A pointer in pkc sram.
1598  *
1599  * Register|BitsName
1600  * ---------------|---------------
1601  * SW_CFG2 | MASA_POINT
1602  *
1603  * @param PKCx PKC instance
1604  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1605  * @retval None
1606  */
1607 __STATIC_INLINE void ll_pkc_set_mas_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1608 {
1609  MODIFY_REG(PKCx->SW_CFG2, PKC_SW_CFG2_MASA_POINT, pointer << PKC_SW_CFG2_MASA_POINT_POS);
1610 }
1611 
1612 /**
1613  * @brief Get modular add/sub parameter A pointer in pkc sram.
1614  *
1615  * Register|BitsName
1616  * ---------------|---------------
1617  * SW_CFG2 | MASA_POINT
1618  *
1619  * @param PKCx PKC instance
1620  * @retval Return value is between: 0 ~ 0x200
1621  */
1622 __STATIC_INLINE uint32_t ll_pkc_get_mas_a_pointer(pkc_regs_t *PKCx)
1623 {
1624  return (READ_BITS(PKCx->SW_CFG2, PKC_SW_CFG2_MASA_POINT) >> PKC_SW_CFG2_MASA_POINT_POS);
1625 }
1626 
1627 /**
1628  * @brief Set modular add/sub parameter B pointer in pkc sram.
1629  *
1630  * Register|BitsName
1631  * ---------------|---------------
1632  * SW_CFG2 | MASB_POINT
1633  *
1634  * @param PKCx PKC instance
1635  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1636  * @retval None
1637  */
1638 __STATIC_INLINE void ll_pkc_set_mas_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1639 {
1640  MODIFY_REG(PKCx->SW_CFG2, PKC_SW_CFG2_MASB_POINT, pointer << PKC_SW_CFG2_MASB_POINT_POS);
1641 }
1642 
1643 /**
1644  * @brief Get modular add/sub parameter B pointer in pkc sram.
1645  *
1646  * Register|BitsName
1647  * ---------------|---------------
1648  * SW_CFG2 | MASB_POINT
1649  *
1650  * @param PKCx PKC instance
1651  * @retval Return value is between: 0 ~ 0x200
1652  */
1653 __STATIC_INLINE uint32_t ll_pkc_get_mas_b_pointer(pkc_regs_t *PKCx)
1654 {
1655  return (READ_BITS(PKCx->SW_CFG2, PKC_SW_CFG2_MASB_POINT) >> PKC_SW_CFG2_MASB_POINT_POS);
1656 }
1657 
1658 /**
1659  * @brief Set modular add/sub parameter P pointer in pkc sram.
1660  *
1661  * Register|BitsName
1662  * ---------------|---------------
1663  * SW_CFG3 | MASP_POINT
1664  *
1665  * @param PKCx PKC instance
1666  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1667  * @retval None
1668  */
1669 __STATIC_INLINE void ll_pkc_set_mas_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1670 {
1671  MODIFY_REG(PKCx->SW_CFG3, PKC_SW_CFG3_MASP_POINT, pointer << PKC_SW_CFG3_MASP_POINT_POS);
1672 }
1673 
1674 /**
1675  * @brief Get modular add/sub parameter P pointer in pkc sram.
1676  *
1677  * Register|BitsName
1678  * ---------------|---------------
1679  * SW_CFG3 | MASP_POINT
1680  *
1681  * @param PKCx PKC instance
1682  * @retval Return value is between: 0 ~ 0x200
1683  */
1684 __STATIC_INLINE uint32_t ll_pkc_get_mas_p_pointer(pkc_regs_t *PKCx)
1685 {
1686  return (READ_BITS(PKCx->SW_CFG3, PKC_SW_CFG3_MASP_POINT) >> PKC_SW_CFG3_MASP_POINT_POS);
1687 }
1688 
1689 /**
1690  * @brief Set modular add/sub parameter C pointer in pkc sram.
1691  *
1692  * Register|BitsName
1693  * ---------------|---------------
1694  * SW_CFG3 | MASC_POINT
1695  *
1696  * @param PKCx PKC instance
1697  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1698  * @retval None
1699  */
1700 __STATIC_INLINE void ll_pkc_set_mas_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1701 {
1702  MODIFY_REG(PKCx->SW_CFG3, PKC_SW_CFG3_MASC_POINT, pointer << PKC_SW_CFG3_MASC_POINT_POS);
1703 }
1704 
1705 /**
1706  * @brief Get modular add/sub parameter C pointer in pkc sram.
1707  *
1708  * Register|BitsName
1709  * ---------------|---------------
1710  * SW_CFG3 | MASC_POINT
1711  *
1712  * @param PKCx PKC instance
1713  * @retval Return value is between: 0 ~ 0x200
1714  */
1715 __STATIC_INLINE uint32_t ll_pkc_get_mas_c_pointer(pkc_regs_t *PKCx)
1716 {
1717  return (READ_BITS(PKCx->SW_CFG3, PKC_SW_CFG3_MASC_POINT) >> PKC_SW_CFG3_MASC_POINT_POS);
1718 }
1719 
1720 /**
1721  * @brief Set modular invertion parameter U pointer in pkc sram.
1722  *
1723  * Register|BitsName
1724  * ---------------|---------------
1725  * SW_CFG4 | MIU_POINT
1726  *
1727  * @param PKCx PKC instance
1728  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1729  * @retval None
1730  */
1731 __STATIC_INLINE void ll_pkc_set_mi_u_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1732 {
1733  MODIFY_REG(PKCx->SW_CFG4, PKC_SW_CFG4_MIU_POINT, pointer << PKC_SW_CFG4_MIU_POINT_POS);
1734 }
1735 
1736 /**
1737  * @brief Get modular invertion parameter U pointer in pkc sram.
1738  *
1739  * Register|BitsName
1740  * ---------------|---------------
1741  * SW_CFG4 | MIU_POINT
1742  *
1743  * @param PKCx PKC instance
1744  * @retval Return value is between: 0 ~ 0x200
1745  */
1746 __STATIC_INLINE uint32_t ll_pkc_get_mi_u_pointer(pkc_regs_t *PKCx)
1747 {
1748  return (READ_BITS(PKCx->SW_CFG4, PKC_SW_CFG4_MIU_POINT) >> PKC_SW_CFG4_MIU_POINT_POS);
1749 }
1750 
1751 /**
1752  * @brief Set modular invertion parameter V pointer in pkc sram.
1753  *
1754  * Register|BitsName
1755  * ---------------|---------------
1756  * SW_CFG4 | MIV_POINT
1757  *
1758  * @param PKCx PKC instance
1759  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1760  * @retval None
1761  */
1762 __STATIC_INLINE void ll_pkc_set_mi_v_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1763 {
1764  MODIFY_REG(PKCx->SW_CFG4, PKC_SW_CFG4_MIV_POINT, pointer << PKC_SW_CFG4_MIV_POINT_POS);
1765 }
1766 
1767 /**
1768  * @brief Get modular invertion parameter V pointer in pkc sram.
1769  *
1770  * Register|BitsName
1771  * ---------------|---------------
1772  * SW_CFG4 | MIV_POINT
1773  *
1774  * @param PKCx PKC instance
1775  * @retval Return value is between: 0 ~ 0x200
1776  */
1777 __STATIC_INLINE uint32_t ll_pkc_get_mi_v_pointer(pkc_regs_t *PKCx)
1778 {
1779  return (READ_BITS(PKCx->SW_CFG4, PKC_SW_CFG4_MIV_POINT) >> PKC_SW_CFG4_MIV_POINT_POS);
1780 }
1781 
1782 /**
1783  * @brief Set modular invertion parameter X1 pointer in pkc sram.
1784  *
1785  * Register|BitsName
1786  * ---------------|---------------
1787  * SW_CFG5 | MIX1_POINT
1788  *
1789  * @param PKCx PKC instance
1790  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1791  * @retval None
1792  */
1793 __STATIC_INLINE void ll_pkc_set_mi_x1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1794 {
1795  MODIFY_REG(PKCx->SW_CFG5, PKC_SW_CFG5_MIX1_POINT, pointer << PKC_SW_CFG5_MIX1_POINT_POS);
1796 }
1797 
1798 /**
1799  * @brief Get modular invertion parameter X1 pointer in pkc sram.
1800  *
1801  * Register|BitsName
1802  * ---------------|---------------
1803  * SW_CFG5 | MIX1_POINT
1804  *
1805  * @param PKCx PKC instance
1806  * @retval Return value is between: 0 ~ 0x200
1807  */
1808 __STATIC_INLINE uint32_t ll_pkc_get_mi_x1_pointer(pkc_regs_t *PKCx)
1809 {
1810  return (READ_BITS(PKCx->SW_CFG5, PKC_SW_CFG5_MIX1_POINT) >> PKC_SW_CFG5_MIX1_POINT_POS);
1811 }
1812 
1813 /**
1814  * @brief Set modular invertion parameter X1 pointer in pkc sram.
1815  *
1816  * Register|BitsName
1817  * ---------------|---------------
1818  * SW_CFG5 | MIX2_POINT
1819  *
1820  * @param PKCx PKC instance
1821  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1822  * @retval None
1823  */
1824 __STATIC_INLINE void ll_pkc_set_mi_x2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1825 {
1826  MODIFY_REG(PKCx->SW_CFG5, PKC_SW_CFG5_MIX2_POINT, pointer << PKC_SW_CFG5_MIX2_POINT_POS);
1827 }
1828 
1829 /**
1830  * @brief Get modular invertion parameter X1 pointer in pkc sram.
1831  *
1832  * Register|BitsName
1833  * ---------------|---------------
1834  * SW_CFG5 | MIX2_POINT
1835  *
1836  * @param PKCx PKC instance
1837  * @retval Return value is between: 0 ~ 0x200
1838  */
1839 __STATIC_INLINE uint32_t ll_pkc_get_mi_x2_pointer(pkc_regs_t *PKCx)
1840 {
1841  return (READ_BITS(PKCx->SW_CFG5, PKC_SW_CFG5_MIX2_POINT) >> PKC_SW_CFG5_MIX2_POINT_POS);
1842 }
1843 
1844 /**
1845  * @brief Set modular invertion parameter Tmp pointer in pkc sram.
1846  *
1847  * Register|BitsName
1848  * ---------------|---------------
1849  * SW_CFG6 | MIT_POINT
1850  *
1851  * @param PKCx PKC instance
1852  * @param pointer This parameter is the offset in pkc sram, and the value can between: 0 ~ 0x200
1853  * @retval None
1854  */
1855 __STATIC_INLINE void ll_pkc_set_swmi_tmp_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1856 {
1857  MODIFY_REG(PKCx->SW_CFG6, PKC_SW_CFG6_MIT_POINT, pointer << PKC_SW_CFG6_MIT_POINT_POS);
1858 }
1859 
1860 /**
1861  * @brief Get modular invertion parameter Tmp pointer in pkc sram.
1862  *
1863  * Register|BitsName
1864  * ---------------|---------------
1865  * SW_CFG6 | MIT_POINT
1866  *
1867  * @param PKCx PKC instance
1868  * @retval Return value is between: 0 ~ 0x200
1869  */
1870 __STATIC_INLINE uint32_t ll_pkc_get_swmi_tmp_pointer(pkc_regs_t *PKCx)
1871 {
1872  return (READ_BITS(PKCx->SW_CFG6, PKC_SW_CFG6_MIT_POINT) >> PKC_SW_CFG6_MIT_POINT_POS);
1873 }
1874 
1875 /**
1876  * @brief Set operation word length-bits.
1877  *
1878  * Register|BitsName
1879  * ---------------|---------------
1880  * SW_CFG7 | WORDLEN
1881  *
1882  * @param PKCx PKC instance
1883  * @param WordLength This parameter can be one of the following values: 256 ~ 2048
1884  * @retval None
1885  */
1886 __STATIC_INLINE void ll_pkc_set_operation_word_length(pkc_regs_t *PKCx, uint32_t WordLength)
1887 {
1888  MODIFY_REG(PKCx->SW_CFG7, PKC_SW_CFG7_LEN, (WordLength >> 5) - 1);
1889 }
1890 
1891 /**
1892  * @brief Get operation word length-bits.
1893  *
1894  * Register|BitsName
1895  * ---------------|---------------
1896  * SW_CFG7 | WORDLEN
1897  *
1898  * @param PKCx PKC instance
1899  * @retval Return value is between: 256 ~ 2048
1900  */
1901 __STATIC_INLINE uint32_t ll_pkc_get_operation_word_length(pkc_regs_t *PKCx)
1902 {
1903  return ((READ_BITS(PKCx->SW_CFG7, PKC_SW_CFG7_LEN) + 1) << 5);
1904 }
1905 
1906 /**
1907  * @brief Get K output in invertion operation.
1908  *
1909  * Register|BitsName
1910  * ---------------|---------------
1911  * SW_CFG8 | MIKOUT
1912  *
1913  * @param PKCx PKC instance
1914  * @retval Return value is between: 0 ~ 0x1FFF
1915  */
1916 __STATIC_INLINE uint32_t ll_pkc_get_mik_output(pkc_regs_t *PKCx)
1917 {
1918  return (READ_REG(PKCx->SW_CFG8) & PKC_SW_CFG8_MIK_OUT);
1919 }
1920 
1921 /**
1922  * @brief Set dummy multiply seed.
1923  *
1924  * Register|BitsName
1925  * ---------------|---------------
1926  * SW_CFG9 | DMRNGSEED
1927  *
1928  * @param PKCx PKC instance
1929  * @param seed This parameter can be one of the following values: 0 ~ 0xFFFFFFFF
1930  * @retval None
1931  */
1932 __STATIC_INLINE void ll_pkc_set_dummy_multiply_seed(pkc_regs_t *PKCx, uint32_t seed)
1933 {
1934  WRITE_REG(PKCx->SW_CFG9, seed);
1935 }
1936 
1937 /**
1938  * @brief Get dummy multiply seed.
1939  *
1940  * Register|BitsName
1941  * ---------------|---------------
1942  * SW_CFG9 | DMRNGSEED
1943  *
1944  * @param PKCx PKC instance
1945  * @retval Return value is between: 0 ~ 0xFFFFFFFF
1946  */
1947 __STATIC_INLINE uint32_t ll_pkc_get_dummy_multiply_seed(pkc_regs_t *PKCx)
1948 {
1949  return (READ_REG(PKCx->SW_CFG9));
1950 }
1951 
1952 /**
1953  * @brief Set big integer operand A pointer in pkc sram.
1954  *
1955  * Register|BitsName
1956  * ---------------|---------------
1957  * SW_CFG10 | BMA_POINT
1958  *
1959  * @param PKCx PKC instance
1960  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
1961  * @retval None
1962  */
1963 __STATIC_INLINE void ll_pkc_set_bm_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1964 {
1965  MODIFY_REG(PKCx->SW_CFG10, PKC_SW_CFG10_BMA_POINT, pointer << PKC_SW_CFG10_BMA_POINT_POS);
1966 }
1967 
1968 /**
1969  * @brief Get big integer operand A pointer in pkc sram.
1970  *
1971  * Register|BitsName
1972  * ---------------|---------------
1973  * SW_CFG10 | BMA_POINT
1974  *
1975  * @param PKCx PKC instance
1976  * @retval Return value is between: 0 ~ 0x1FF
1977  */
1978 __STATIC_INLINE uint32_t ll_pkc_get_bm_a_pointer(pkc_regs_t *PKCx)
1979 {
1980  return (READ_BITS(PKCx->SW_CFG10, PKC_SW_CFG10_BMA_POINT) >> PKC_SW_CFG10_BMA_POINT_POS);
1981 }
1982 
1983 /**
1984  * @brief Set big integer operand B pointer in pkc sram.
1985  *
1986  * Register|BitsName
1987  * ---------------|---------------
1988  * SW_CFG10 | BMB_POINT
1989  *
1990  * @param PKCx PKC instance
1991  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
1992  * @retval None
1993  */
1994 __STATIC_INLINE void ll_pkc_set_bm_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
1995 {
1996  MODIFY_REG(PKCx->SW_CFG10, PKC_SW_CFG10_BMB_POINT, pointer << PKC_SW_CFG10_BMB_POINT_POS);
1997 }
1998 
1999 /**
2000  * @brief Get big integer operand B pointer in pkc sram.
2001  *
2002  * Register|BitsName
2003  * ---------------|---------------
2004  * SW_CFG10 | BMB_POINT
2005  *
2006  * @param PKCx PKC instance
2007  * @retval Return value is between: 0 ~ 0x1FF
2008  */
2009 __STATIC_INLINE uint32_t ll_pkc_get_bm_b_pointer(pkc_regs_t *PKCx)
2010 {
2011  return (READ_BITS(PKCx->SW_CFG10, PKC_SW_CFG10_BMB_POINT) >> PKC_SW_CFG10_BMB_POINT_POS);
2012 }
2013 
2014 /**
2015  * @brief Set big integer result C pointer in pkc sram.
2016  *
2017  * Register|BitsName
2018  * ---------------|---------------
2019  * SW_CFG11 | BMC_POINT
2020  *
2021  * @param PKCx PKC instance
2022  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
2023  * @retval None
2024  */
2025 __STATIC_INLINE void ll_pkc_set_bm_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
2026 {
2027  MODIFY_REG(PKCx->SW_CFG11, PKC_SW_CFG11_BMC_POINT, pointer << PKC_SW_CFG11_BMC_POINT_POS);
2028 }
2029 
2030 /**
2031  * @brief Get big integer result C pointer in pkc sram.
2032  *
2033  * Register|BitsName
2034  * ---------------|---------------
2035  * SW_CFG11 | BMC_POINT
2036  *
2037  * @param PKCx PKC instance
2038  * @retval Return value is between: 0 ~ 0x1FF
2039  */
2040 __STATIC_INLINE uint32_t ll_pkc_get_bm_c_pointer(pkc_regs_t *PKCx)
2041 {
2042  return (READ_BITS(PKCx->SW_CFG11, PKC_SW_CFG11_BMC_POINT) >> PKC_SW_CFG11_BMC_POINT_POS);
2043 }
2044 
2045 /**
2046  * @brief Set big integer operand A pointer in pkc sram.
2047  *
2048  * Register|BitsName
2049  * ---------------|---------------
2050  * SW_CFG11 | BAA_POINT
2051  *
2052  * @param PKCx PKC instance
2053  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
2054  * @retval None
2055  */
2056 __STATIC_INLINE void ll_pkc_set_ba_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
2057 {
2058  MODIFY_REG(PKCx->SW_CFG11, PKC_SW_CFG11_BAA_POINT, pointer << PKC_SW_CFG11_BAA_POINT_POS);
2059 }
2060 
2061 /**
2062  * @brief Get big integer operand A pointer in pkc sram.
2063  *
2064  * Register|BitsName
2065  * ---------------|---------------
2066  * SW_CFG11 | BAA_POINT
2067  *
2068  * @param PKCx PKC instance
2069  * @retval Return value is between: 0 ~ 0x1FF
2070  */
2071 __STATIC_INLINE uint32_t ll_pkc_get_ba_a_pointer(pkc_regs_t *PKCx)
2072 {
2073  return (READ_BITS(PKCx->SW_CFG11, PKC_SW_CFG11_BAA_POINT) >> PKC_SW_CFG11_BAA_POINT_POS);
2074 }
2075 
2076 /**
2077  * @brief Set big integer operand B pointer in pkc sram.
2078  *
2079  * Register|BitsName
2080  * ---------------|---------------
2081  * SW_CFG12 | BAB_POINT
2082  *
2083  * @param PKCx PKC instance
2084  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
2085  * @retval None
2086  */
2087 __STATIC_INLINE void ll_pkc_set_ba_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
2088 {
2089  MODIFY_REG(PKCx->SW_CFG12, PKC_SW_CFG12_BAB_POINT, pointer << PKC_SW_CFG12_BAB_POINT_POS);
2090 }
2091 
2092 /**
2093  * @brief Get big integer operand B pointer in pkc sram.
2094  *
2095  * Register|BitsName
2096  * ---------------|---------------
2097  * SW_CFG12 | BAB_POINT
2098  *
2099  * @param PKCx PKC instance
2100  * @retval Return value is between: 0 ~ 0x1FF
2101  */
2102 __STATIC_INLINE uint32_t ll_pkc_get_ba_b_pointer(pkc_regs_t *PKCx)
2103 {
2104  return (READ_BITS(PKCx->SW_CFG12, PKC_SW_CFG12_BAB_POINT) >> PKC_SW_CFG12_BAB_POINT_POS);
2105 }
2106 
2107 /**
2108  * @brief Set big integer result C pointer in pkc sram.
2109  *
2110  * Register|BitsName
2111  * ---------------|---------------
2112  * SW_CFG12 | BAC_POINT
2113  *
2114  * @param PKCx PKC instance
2115  * @param pointer This parameter can be one of the following values: 0 ~ 0x1FF
2116  * @retval None
2117  */
2118 __STATIC_INLINE void ll_pkc_set_ba_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
2119 {
2120  MODIFY_REG(PKCx->SW_CFG12, PKC_SW_CFG12_BAC_POINT, pointer << PKC_SW_CFG12_BAC_POINT_POS);
2121 }
2122 
2123 /**
2124  * @brief Get big integer result C pointer in pkc sram.
2125  *
2126  * Register|BitsName
2127  * ---------------|---------------
2128  * SW_CFG12 | BAC_POINT
2129  *
2130  * @param PKCx PKC instance
2131  * @retval Return value is between: 0 ~ 0x1FF
2132  */
2133 __STATIC_INLINE uint32_t ll_pkc_get_ba_c_pointer(pkc_regs_t *PKCx)
2134 {
2135  return (READ_BITS(PKCx->SW_CFG12, PKC_SW_CFG12_BAC_POINT) >> PKC_SW_CFG12_BAC_POINT_POS);
2136 }
2137 
2138 /**
2139  * @brief Set random clock gating seed.
2140  *
2141  * Register|BitsName
2142  * ---------------|---------------
2143  * SW_CFG13 | RANDSEED
2144  *
2145  * @param PKCx PKC instance
2146  * @param seed This parameter can be one of the following values: 0 ~ 0xFFFFFFFF
2147  * @retval None
2148  */
2149 __STATIC_INLINE void ll_pkc_set_random_clock_gating_seed(pkc_regs_t *PKCx, uint32_t seed)
2150 {
2151  WRITE_REG(PKCx->SW_CFG13, seed);
2152 }
2153 
2154 /**
2155  * @brief Get random clock gating seed.
2156  *
2157  * Register|BitsName
2158  * ---------------|---------------
2159  * SW_CFG13 | RANDSEED
2160  *
2161  * @param PKCx PKC instance
2162  * @retval Return value is between: 0 ~ 0xFFFFFFFF
2163  */
2164 __STATIC_INLINE uint32_t ll_pkc_get_random_clock_gating_seed(pkc_regs_t *PKCx)
2165 {
2166  return (READ_REG(PKCx->SW_CFG13));
2167 }
2168 
2169 /** @} */
2170 
2171 /** @defgroup PKC_LL_EF_IT_Management IT_Management
2172  * @{
2173  */
2174 
2175 /**
2176  * @brief Enable the operation done interrupt.
2177  *
2178  * Register|BitsName
2179  * ---------------|---------------
2180  * INT_EN | DONE
2181  *
2182  * @param PKCx PKC instance
2183  * @retval none.
2184  */
2185 __STATIC_INLINE void ll_pkc_enable_it_done(pkc_regs_t *PKCx)
2186 {
2187  SET_BITS(PKCx->INT_EN, PKC_INT_EN_CPLT_INT_EN);
2188 }
2189 
2190 /**
2191  * @brief Enable the operation error interrupt.
2192  *
2193  * Register|BitsName
2194  * ---------------|---------------
2195  * INT_EN | ERR
2196  *
2197  * @param PKCx PKC instance
2198  * @retval none.
2199  */
2200 __STATIC_INLINE void ll_pkc_enable_it_err(pkc_regs_t *PKCx)
2201 {
2202  SET_BITS(PKCx->INT_EN, PKC_INT_EN_ERR_INT_EN);
2203 }
2204 
2205 /**
2206  * @brief Enable the big integer overflow interrupt.
2207  *
2208  * Register|BitsName
2209  * ---------------|---------------
2210  * INT_EN | BAOVF
2211  *
2212  * @param PKCx PKC instance
2213  * @retval none.
2214  */
2215 __STATIC_INLINE void ll_pkc_enable_it_big_add_overflow(pkc_regs_t *PKCx)
2216 {
2217  SET_BITS(PKCx->INT_EN, PKC_INT_EN_BIAO_INT_EN);
2218 }
2219 
2220 /**
2221  * @brief Disable the operation done interrupt.
2222  *
2223  * Register|BitsName
2224  * ---------------|---------------
2225  * INT_EN | DONE
2226  *
2227  * @param PKCx PKC instance
2228  * @retval none.
2229  */
2230 __STATIC_INLINE void ll_pkc_disable_it_done(pkc_regs_t *PKCx)
2231 {
2232  CLEAR_BITS(PKCx->INT_EN, PKC_INT_EN_CPLT_INT_EN);
2233 }
2234 
2235 /**
2236  * @brief Disable the operation error interrupt.
2237  *
2238  * Register|BitsName
2239  * ---------------|---------------
2240  * INT_EN | ERR
2241  *
2242  * @param PKCx PKC instance
2243  * @retval none.
2244  */
2245 __STATIC_INLINE void ll_pkc_disable_it_err(pkc_regs_t *PKCx)
2246 {
2247  CLEAR_BITS(PKCx->INT_EN, PKC_INT_EN_ERR_INT_EN);
2248 }
2249 
2250 /**
2251  * @brief Disable the big integer overflow interrupt.
2252  *
2253  * Register|BitsName
2254  * ---------------|---------------
2255  * INT_EN | BAOVF
2256  *
2257  * @param PKCx PKC instance
2258  * @retval none.
2259  */
2260 __STATIC_INLINE void ll_pkc_disable_it_big_add_overflow(pkc_regs_t *PKCx)
2261 {
2262  CLEAR_BITS(PKCx->INT_EN, PKC_INT_EN_BIAO_INT_EN);
2263 }
2264 
2265 /**
2266  * @brief Indicate whether the operation done interrupt is enable.
2267  *
2268  * Register|BitsName
2269  * ---------------|---------------
2270  * INT_EN | DONE
2271  *
2272  * @param PKCx PKC instance
2273  * @retval State of bit (1 or 0).
2274  */
2275 __STATIC_INLINE uint32_t ll_pkc_is_enable_it_done(pkc_regs_t *PKCx)
2276 {
2277  return (READ_BITS(PKCx->INT_EN, PKC_INT_EN_CPLT_INT_EN) == PKC_INT_EN_CPLT_INT_EN);
2278 }
2279 
2280 /**
2281  * @brief Indicate whether the operation error interrupt is enable.
2282  *
2283  * Register|BitsName
2284  * ---------------|---------------
2285  * INT_EN | ERR
2286  *
2287  * @param PKCx PKC instance
2288  * @retval State of bit (1 or 0).
2289  */
2290 __STATIC_INLINE uint32_t ll_pkc_is_enable_it_err(pkc_regs_t *PKCx)
2291 {
2292  return (READ_BITS(PKCx->INT_EN, PKC_INT_EN_ERR_INT_EN) == PKC_INT_EN_ERR_INT_EN);
2293 }
2294 
2295 /**
2296  * @brief Indicate whether the big integer overflow interrupt is enable.
2297  *
2298  * Register|BitsName
2299  * ---------------|---------------
2300  * INT_EN | BAOVF
2301  *
2302  * @param PKCx PKC instance
2303  * @retval State of bit (1 or 0).
2304  */
2305 __STATIC_INLINE uint32_t ll_pkc_is_enable_it_big_add_overflow(pkc_regs_t *PKCx)
2306 {
2307  return (READ_BITS(PKCx->INT_EN, PKC_INT_EN_BIAO_INT_EN) == PKC_INT_EN_BIAO_INT_EN);
2308 }
2309 
2310 /** @} */
2311 
2312 /** @defgroup PKC_LL_EF_FLAG_Management FLAG_Management
2313  * @{
2314  */
2315 
2316 /**
2317  * @brief Indicate whether the operation done interrupt is pending.
2318  *
2319  * Register|BitsName
2320  * ---------------|---------------
2321  * INT_STAT | DONE
2322  *
2323  * @param PKCx PKC instance
2324  * @retval State of bit (1 or 0).
2325  */
2326 __STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_done(pkc_regs_t *PKCx)
2327 {
2328  return (READ_BITS(PKCx->INT_STAT, PKC_INT_STAT_CPLT_INT_FLAG) == PKC_INT_STAT_CPLT_INT_FLAG);
2329 }
2330 
2331 /**
2332  * @brief Indicate whether the operation error interrupt is pending.
2333  *
2334  * Register|BitsName
2335  * ---------------|---------------
2336  * INT_STAT | ERR
2337  *
2338  * @param PKCx PKC instance
2339  * @retval State of bit (1 or 0).
2340  */
2341 __STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_err(pkc_regs_t *PKCx)
2342 {
2343  return (READ_BITS(PKCx->INT_STAT, PKC_INT_STAT_ERR_INT_FLAG) == PKC_INT_STAT_ERR_INT_FLAG);
2344 }
2345 
2346 /**
2347  * @brief Indicate whether the big integer overflow interrupt is pending.
2348  *
2349  * Register|BitsName
2350  * ---------------|---------------
2351  * INT_STAT | BAOVF
2352  *
2353  * @param PKCx PKC instance
2354  * @retval State of bit (1 or 0).
2355  */
2356 __STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_big_add_overflow(pkc_regs_t *PKCx)
2357 {
2358  return (READ_BITS(PKCx->INT_STAT, PKC_INT_STAT_BIAO_INT_FLAG) == PKC_INT_STAT_BIAO_INT_FLAG);
2359 }
2360 
2361 /**
2362  * @brief Clear the operation done interrupt flag.
2363  *
2364  * Register|BitsName
2365  * ---------------|---------------
2366  * INT_STAT | DONE
2367  *
2368  * @param PKCx PKC instance
2369  * @retval none.
2370  */
2371 __STATIC_INLINE void ll_pkc_clear_flag_it_done(pkc_regs_t *PKCx)
2372 {
2373  SET_BITS(PKCx->INT_STAT, PKC_INT_STAT_CPLT_INT_FLAG);
2374 }
2375 
2376 /**
2377  * @brief Clear the operation error interrupt flag.
2378  *
2379  * Register|BitsName
2380  * ---------------|---------------
2381  * INT_STAT | ERR_INT
2382  *
2383  * @param PKCx PKC instance
2384  * @retval none.
2385  */
2386 __STATIC_INLINE void ll_pkc_clear_flag_it_err(pkc_regs_t *PKCx)
2387 {
2388  SET_BITS(PKCx->INT_STAT, PKC_INT_STAT_ERR_INT_FLAG);
2389 }
2390 
2391 /**
2392  * @brief Clear the big integer overflow interrupt flag.
2393  *
2394  * Register|BitsName
2395  * ---------------|---------------
2396  * INT_STAT | BAOVF
2397  *
2398  * @param PKCx PKC instance
2399  * @retval none.
2400  */
2401 __STATIC_INLINE void ll_pkc_clear_flag_it_big_add_overflow(pkc_regs_t *PKCx)
2402 {
2403  SET_BITS(PKCx->INT_STAT, PKC_INT_STAT_BIAO_INT_FLAG);
2404 }
2405 
2406 /**
2407  * @brief Indicate whether the busy flag is set.
2408  *
2409  * Register|BitsName
2410  * ---------------|---------------
2411  * STAT | BUSY
2412  *
2413  * @param PKCx PKC instance
2414  * @retval State of bit (1 or 0).
2415  */
2416 __STATIC_INLINE uint32_t ll_pkc_is_action_flag_busy(pkc_regs_t *PKCx)
2417 {
2418  return (READ_BITS(PKCx->STAT, PKC_STAT_BUSY) == PKC_STAT_BUSY);
2419 }
2420 
2421 /** @} */
2422 
2423 /** @} */
2424 
2425 #endif /* PKC */
2426 
2427 #ifdef __cplusplus
2428 }
2429 #endif
2430 
2431 #endif /* __GR5XX_LL_PKC_H__ */
2432 
2433 /** @} */
2434 
2435 /** @} */
2436 
2437 /** @} */
ll_pkc_is_enabled_hardware_start
__STATIC_INLINE uint32_t ll_pkc_is_enabled_hardware_start(pkc_regs_t *PKCx)
Indicate whether the pkc start in hardware mode is enabled.
Definition: ll_pkc.h:358
ll_pkc_enable_it_err
__STATIC_INLINE void ll_pkc_enable_it_err(pkc_regs_t *PKCx)
Enable the operation error interrupt.
Definition: ll_pkc.h:2200
ll_pkc_get_bm_a_pointer
__STATIC_INLINE uint32_t ll_pkc_get_bm_a_pointer(pkc_regs_t *PKCx)
Get big integer operand A pointer in pkc sram.
Definition: ll_pkc.h:1978
ll_pkc_get_tmp6_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp6_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp6 pointer in pkc sram.
Definition: ll_pkc.h:1037
ll_pkc_set_k_pointer
__STATIC_INLINE void ll_pkc_set_k_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter k pointer in pkc sram.
Definition: ll_pkc.h:464
ll_pkc_get_tmp1_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp1_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp1 pointer in pkc sram.
Definition: ll_pkc.h:882
ll_pkc_set_tmpk_pointer
__STATIC_INLINE void ll_pkc_set_tmpk_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter TmpK pointer in pkc sram.
Definition: ll_pkc.h:1177
ll_pkc_get_gy_pointer
__STATIC_INLINE uint32_t ll_pkc_get_gy_pointer(pkc_regs_t *PKCx)
Get PKC parameter Gy pointer in pkc sram.
Definition: ll_pkc.h:634
ll_pkc_disable_software
__STATIC_INLINE void ll_pkc_disable_software(pkc_regs_t *PKCx)
Disable pkc software mode.
Definition: ll_pkc.h:388
ll_pkc_get_tmpk_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmpk_pointer(pkc_regs_t *PKCx)
Get PKC parameter TmpK pointer in pkc sram.
Definition: ll_pkc.h:1192
ll_pkc_get_random_clock_gating_seed
__STATIC_INLINE uint32_t ll_pkc_get_random_clock_gating_seed(pkc_regs_t *PKCx)
Get random clock gating seed.
Definition: ll_pkc.h:2164
ll_pkc_is_enabled
__STATIC_INLINE uint32_t ll_pkc_is_enabled(pkc_regs_t *PKCx)
Indicate whether the pkc is enabled.
Definition: ll_pkc.h:313
ll_pkc_get_p_pointer
__STATIC_INLINE uint32_t ll_pkc_get_p_pointer(pkc_regs_t *PKCx)
Get PKC parameter p pointer in pkc sram.
Definition: ll_pkc.h:541
ll_pkc_get_gx_pointer
__STATIC_INLINE uint32_t ll_pkc_get_gx_pointer(pkc_regs_t *PKCx)
Get PKC parameter Gx pointer in pkc sram.
Definition: ll_pkc.h:603
ll_pkc_clear_flag_it_done
__STATIC_INLINE void ll_pkc_clear_flag_it_done(pkc_regs_t *PKCx)
Clear the operation done interrupt flag.
Definition: ll_pkc.h:2371
ll_pkc_set_mm_a_pointer
__STATIC_INLINE void ll_pkc_set_mm_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular multiplication parameter A pointer in pkc sram.
Definition: ll_pkc.h:1483
ll_pkc_set_mi_x1_pointer
__STATIC_INLINE void ll_pkc_set_mi_x1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular invertion parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1793
ll_pkc_set_operation_word_length
__STATIC_INLINE void ll_pkc_set_operation_word_length(pkc_regs_t *PKCx, uint32_t WordLength)
Set operation word length-bits.
Definition: ll_pkc.h:1886
ll_pkc_get_r0z_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r0z_pointer(pkc_regs_t *PKCx)
Get PKC parameter R0z pointer in pkc sram.
Definition: ll_pkc.h:758
ll_pkc_get_mitmp_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mitmp_pointer(pkc_regs_t *PKCx)
Get PKC parameter MITmp pointer in pkc sram.
Definition: ll_pkc.h:1161
ll_pkc_set_mitmp_pointer
__STATIC_INLINE void ll_pkc_set_mitmp_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter MITmp pointer in pkc sram.
Definition: ll_pkc.h:1146
ll_pkc_get_mm_a_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mm_a_pointer(pkc_regs_t *PKCx)
Get modular multiplication parameter A pointer in pkc sram.
Definition: ll_pkc.h:1498
ll_pkc_set_gx_pointer
__STATIC_INLINE void ll_pkc_set_gx_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Gx pointer in pkc sram.
Definition: ll_pkc.h:588
ll_pkc_get_constp
__STATIC_INLINE uint32_t ll_pkc_get_constp(pkc_regs_t *PKCx)
Get constant value for montgomery multiply in pkc sram.
Definition: ll_pkc.h:1285
ll_pkc_set_r_pointer
__STATIC_INLINE void ll_pkc_set_r_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter r pointer in pkc sram.
Definition: ll_pkc.h:495
ll_ecc_curve_init_t
struct _ll_ecc_curve_init ll_ecc_curve_init_t
LL PKC ECC P-256 Elliptic Curve Init Structure definition.
ll_pkc_get_rsq_pointer
__STATIC_INLINE uint32_t ll_pkc_get_rsq_pointer(pkc_regs_t *PKCx)
Get PKC parameter R^2 pointer in pkc sram.
Definition: ll_pkc.h:572
ll_pkc_enable_dummy_multi
__STATIC_INLINE void ll_pkc_enable_dummy_multi(pkc_regs_t *PKCx)
Enable Dummy Multi in software mode.
Definition: ll_pkc.h:1392
ll_pkc_is_enabled_reset
__STATIC_INLINE uint32_t ll_pkc_is_enabled_reset(pkc_regs_t *PKCx)
Indicate whether the pkc reset is enabled.
Definition: ll_pkc.h:448
ll_pkc_disable_random_clock_gating
__STATIC_INLINE void ll_pkc_disable_random_clock_gating(pkc_regs_t *PKCx)
Disable Random Clock Gating in software mode.
Definition: ll_pkc.h:1452
ll_pkc_set_mm_b_pointer
__STATIC_INLINE void ll_pkc_set_mm_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular multiplication parameter B pointer in pkc sram.
Definition: ll_pkc.h:1514
ll_pkc_set_mas_p_pointer
__STATIC_INLINE void ll_pkc_set_mas_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular add/sub parameter P pointer in pkc sram.
Definition: ll_pkc.h:1669
ll_pkc_get_r1z_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r1z_pointer(pkc_regs_t *PKCx)
Get PKC parameter R1z pointer in pkc sram.
Definition: ll_pkc.h:851
ll_pkc_get_tmp2_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp2_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp2 pointer in pkc sram.
Definition: ll_pkc.h:913
ll_pkc_get_mi_x2_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mi_x2_pointer(pkc_regs_t *PKCx)
Get modular invertion parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1839
ll_pkc_set_r1z_pointer
__STATIC_INLINE void ll_pkc_set_r1z_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R1z pointer in pkc sram.
Definition: ll_pkc.h:836
ll_pkc_get_ba_c_pointer
__STATIC_INLINE uint32_t ll_pkc_get_ba_c_pointer(pkc_regs_t *PKCx)
Get big integer result C pointer in pkc sram.
Definition: ll_pkc.h:2133
_ll_pkc_init::p_ecc_curve
ll_ecc_curve_init_t * p_ecc_curve
Definition: ll_pkc.h:126
_ll_ecc_curve_init::A
uint32_t A[ECC_U32_LENGTH]
Definition: ll_pkc.h:104
ll_pkc_set_bm_a_pointer
__STATIC_INLINE void ll_pkc_set_bm_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer operand A pointer in pkc sram.
Definition: ll_pkc.h:1963
ll_pkc_is_enable_it_big_add_overflow
__STATIC_INLINE uint32_t ll_pkc_is_enable_it_big_add_overflow(pkc_regs_t *PKCx)
Indicate whether the big integer overflow interrupt is enable.
Definition: ll_pkc.h:2305
ll_pkc_get_mas_b_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mas_b_pointer(pkc_regs_t *PKCx)
Get modular add/sub parameter B pointer in pkc sram.
Definition: ll_pkc.h:1653
ll_pkc_disable_it_big_add_overflow
__STATIC_INLINE void ll_pkc_disable_it_big_add_overflow(pkc_regs_t *PKCx)
Disable the big integer overflow interrupt.
Definition: ll_pkc.h:2260
ll_pkc_set_x1_pointer
__STATIC_INLINE void ll_pkc_set_x1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1084
ll_pkc_enable_software_start
__STATIC_INLINE void ll_pkc_enable_software_start(pkc_regs_t *PKCx)
Enable pkc start in software mode.
Definition: ll_pkc.h:1300
ll_pkc_set_mm_c_pointer
__STATIC_INLINE void ll_pkc_set_mm_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular multiplication parameter C pointer in pkc sram.
Definition: ll_pkc.h:1576
_ll_pkc_init::data_bits
uint32_t data_bits
Definition: ll_pkc.h:128
ll_pkc_set_ecc_b_pointer
__STATIC_INLINE void ll_pkc_set_ecc_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set ECC parameter B pointer in pkc sram.
Definition: ll_pkc.h:1239
ll_pkc_set_mas_c_pointer
__STATIC_INLINE void ll_pkc_set_mas_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular add/sub parameter C pointer in pkc sram.
Definition: ll_pkc.h:1700
ll_pkc_get_r1y_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r1y_pointer(pkc_regs_t *PKCx)
Get PKC parameter R1y pointer in pkc sram.
Definition: ll_pkc.h:820
ll_pkc_get_r0y_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r0y_pointer(pkc_regs_t *PKCx)
Get PKC parameter R0y pointer in pkc sram.
Definition: ll_pkc.h:727
ll_pkc_set_mi_v_pointer
__STATIC_INLINE void ll_pkc_set_mi_v_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular invertion parameter V pointer in pkc sram.
Definition: ll_pkc.h:1762
ll_pkc_get_bm_b_pointer
__STATIC_INLINE uint32_t ll_pkc_get_bm_b_pointer(pkc_regs_t *PKCx)
Get big integer operand B pointer in pkc sram.
Definition: ll_pkc.h:2009
_ll_ecc_curve_init
LL PKC ECC P-256 Elliptic Curve Init Structure definition.
Definition: ll_pkc.h:103
_ll_pkc_init
LL PKC Init Structure definition.
Definition: ll_pkc.h:125
ll_pkc_set_x2_pointer
__STATIC_INLINE void ll_pkc_set_x2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter X2 pointer in pkc sram.
Definition: ll_pkc.h:1115
ll_pkc_is_action_flag_busy
__STATIC_INLINE uint32_t ll_pkc_is_action_flag_busy(pkc_regs_t *PKCx)
Indicate whether the busy flag is set.
Definition: ll_pkc.h:2416
ll_pkc_get_gz_pointer
__STATIC_INLINE uint32_t ll_pkc_get_gz_pointer(pkc_regs_t *PKCx)
Get PKC parameter Gz pointer in pkc sram.
Definition: ll_pkc.h:665
ll_pkc_set_r1y_pointer
__STATIC_INLINE void ll_pkc_set_r1y_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R1y pointer in pkc sram.
Definition: ll_pkc.h:805
ll_pkc_set_random_clock_gating_seed
__STATIC_INLINE void ll_pkc_set_random_clock_gating_seed(pkc_regs_t *PKCx, uint32_t seed)
Set random clock gating seed.
Definition: ll_pkc.h:2149
_ll_ecc_curve_init::PRSquare
uint32_t PRSquare[ECC_U32_LENGTH]
Definition: ll_pkc.h:108
gr5x.h
CMSIS Cortex-M# Core Peripheral Access Layer Header File for Device GR5405.
ll_pkc_disable_it_done
__STATIC_INLINE void ll_pkc_disable_it_done(pkc_regs_t *PKCx)
Disable the operation done interrupt.
Definition: ll_pkc.h:2230
ll_pkc_set_swmi_tmp_pointer
__STATIC_INLINE void ll_pkc_set_swmi_tmp_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular invertion parameter Tmp pointer in pkc sram.
Definition: ll_pkc.h:1855
ll_pkc_get_mas_c_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mas_c_pointer(pkc_regs_t *PKCx)
Get modular add/sub parameter C pointer in pkc sram.
Definition: ll_pkc.h:1715
ll_pkc_get_operation_word_length
__STATIC_INLINE uint32_t ll_pkc_get_operation_word_length(pkc_regs_t *PKCx)
Get operation word length-bits.
Definition: ll_pkc.h:1901
ll_pkc_get_mm_c_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mm_c_pointer(pkc_regs_t *PKCx)
Get modular multiplication parameter C pointer in pkc sram.
Definition: ll_pkc.h:1591
ll_pkc_get_mas_p_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mas_p_pointer(pkc_regs_t *PKCx)
Get modular add/sub parameter P pointer in pkc sram.
Definition: ll_pkc.h:1684
ll_pkc_is_action_flag_it_big_add_overflow
__STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_big_add_overflow(pkc_regs_t *PKCx)
Indicate whether the big integer overflow interrupt is pending.
Definition: ll_pkc.h:2356
_ll_ecc_curve_init::H
uint32_t H
Definition: ll_pkc.h:115
ll_pkc_set_r1x_pointer
__STATIC_INLINE void ll_pkc_set_r1x_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R1x pointer in pkc sram.
Definition: ll_pkc.h:774
ll_pkc_set_tmp1_pointer
__STATIC_INLINE void ll_pkc_set_tmp1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp1 pointer in pkc sram.
Definition: ll_pkc.h:867
ll_pkc_set_tmp4_pointer
__STATIC_INLINE void ll_pkc_set_tmp4_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp4 pointer in pkc sram.
Definition: ll_pkc.h:960
ll_pkc_set_tmp2_pointer
__STATIC_INLINE void ll_pkc_set_tmp2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp2 pointer in pkc sram.
Definition: ll_pkc.h:898
ll_pkc_set_constant1_pointer
__STATIC_INLINE void ll_pkc_set_constant1_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Constant1 pointer in pkc sram.
Definition: ll_pkc.h:1053
ll_pkc_get_ecc_b_pointer
__STATIC_INLINE uint32_t ll_pkc_get_ecc_b_pointer(pkc_regs_t *PKCx)
Get ECC parameter B pointer in pkc sram.
Definition: ll_pkc.h:1254
_ll_ecc_curve_init::ConstP
uint32_t ConstP
Definition: ll_pkc.h:109
ll_pkc_set_mm_p_pointer
__STATIC_INLINE void ll_pkc_set_mm_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular multiplication parameter P pointer in pkc sram.
Definition: ll_pkc.h:1545
ll_pkc_get_mm_b_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mm_b_pointer(pkc_regs_t *PKCx)
Get modular multiplication parameter B pointer in pkc sram.
Definition: ll_pkc.h:1529
ll_pkc_get_r_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r_pointer(pkc_regs_t *PKCx)
Get PKC parameter r pointer in pkc sram.
Definition: ll_pkc.h:510
ll_pkc_get_tmp4_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp4_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp4 pointer in pkc sram.
Definition: ll_pkc.h:975
ll_pkc_disable_reset
__STATIC_INLINE void ll_pkc_disable_reset(pkc_regs_t *PKCx)
Disable pkc reset.
Definition: ll_pkc.h:433
ll_pkc_set_mi_x2_pointer
__STATIC_INLINE void ll_pkc_set_mi_x2_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular invertion parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1824
ll_pkc_enable
__STATIC_INLINE void ll_pkc_enable(pkc_regs_t *PKCx)
Enable pkc.
Definition: ll_pkc.h:283
ll_pkc_get_operation_mode
__STATIC_INLINE uint32_t ll_pkc_get_operation_mode(pkc_regs_t *PKCx)
Get operation mode in software mode.
Definition: ll_pkc.h:1377
_ll_ecc_curve_init::P
uint32_t P[ECC_U32_LENGTH]
Definition: ll_pkc.h:107
ll_pkc_get_ba_a_pointer
__STATIC_INLINE uint32_t ll_pkc_get_ba_a_pointer(pkc_regs_t *PKCx)
Get big integer operand A pointer in pkc sram.
Definition: ll_pkc.h:2071
ll_pkc_is_action_flag_it_done
__STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_done(pkc_regs_t *PKCx)
Indicate whether the operation done interrupt is pending.
Definition: ll_pkc.h:2326
ll_pkc_clear_flag_it_err
__STATIC_INLINE void ll_pkc_clear_flag_it_err(pkc_regs_t *PKCx)
Clear the operation error interrupt flag.
Definition: ll_pkc.h:2386
_ll_ecc_point
LL PKC ECC Point Structure definition.
Definition: ll_pkc.h:92
ll_pkc_get_bm_c_pointer
__STATIC_INLINE uint32_t ll_pkc_get_bm_c_pointer(pkc_regs_t *PKCx)
Get big integer result C pointer in pkc sram.
Definition: ll_pkc.h:2040
_ll_ecc_curve_init::NRSquare
uint32_t NRSquare[ECC_U32_LENGTH]
Definition: ll_pkc.h:112
ll_pkc_set_tmp5_pointer
__STATIC_INLINE void ll_pkc_set_tmp5_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp5 pointer in pkc sram.
Definition: ll_pkc.h:991
ll_pkc_set_dummy_multiply_seed
__STATIC_INLINE void ll_pkc_set_dummy_multiply_seed(pkc_regs_t *PKCx, uint32_t seed)
Set dummy multiply seed.
Definition: ll_pkc.h:1932
ECC_U32_LENGTH
#define ECC_U32_LENGTH
Definition: ll_pkc.h:72
ll_pkc_set_ba_c_pointer
__STATIC_INLINE void ll_pkc_set_ba_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer result C pointer in pkc sram.
Definition: ll_pkc.h:2118
ll_pkc_get_mi_x1_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mi_x1_pointer(pkc_regs_t *PKCx)
Get modular invertion parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1808
ll_pkc_set_bm_c_pointer
__STATIC_INLINE void ll_pkc_set_bm_c_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer result C pointer in pkc sram.
Definition: ll_pkc.h:2025
ll_pkc_set_r0x_pointer
__STATIC_INLINE void ll_pkc_set_r0x_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R0x pointer in pkc sram.
Definition: ll_pkc.h:681
ll_pkc_is_enabled_dummy_multi
__STATIC_INLINE uint32_t ll_pkc_is_enabled_dummy_multi(pkc_regs_t *PKCx)
Indicate whether the Dummy Multi in software mode is enabled.
Definition: ll_pkc.h:1422
ll_pkc_disable
__STATIC_INLINE void ll_pkc_disable(pkc_regs_t *PKCx)
Disable pkc.
Definition: ll_pkc.h:298
ll_pkc_get_r1x_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r1x_pointer(pkc_regs_t *PKCx)
Get PKC parameter R1x pointer in pkc sram.
Definition: ll_pkc.h:789
ll_pkc_get_tmp5_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp5_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp5 pointer in pkc sram.
Definition: ll_pkc.h:1006
ll_pkc_get_x2_pointer
__STATIC_INLINE uint32_t ll_pkc_get_x2_pointer(pkc_regs_t *PKCx)
Get PKC parameter X2 pointer in pkc sram.
Definition: ll_pkc.h:1130
ll_pkc_get_mi_v_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mi_v_pointer(pkc_regs_t *PKCx)
Get modular invertion parameter V pointer in pkc sram.
Definition: ll_pkc.h:1777
ll_pkc_disable_software_start
__STATIC_INLINE void ll_pkc_disable_software_start(pkc_regs_t *PKCx)
Disable pkc start in software mode.
Definition: ll_pkc.h:1315
ll_pkc_disable_it_err
__STATIC_INLINE void ll_pkc_disable_it_err(pkc_regs_t *PKCx)
Disable the operation error interrupt.
Definition: ll_pkc.h:2245
ll_pkc_set_r0z_pointer
__STATIC_INLINE void ll_pkc_set_r0z_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R0z pointer in pkc sram.
Definition: ll_pkc.h:743
ll_pkc_get_k_pointer
__STATIC_INLINE uint32_t ll_pkc_get_k_pointer(pkc_regs_t *PKCx)
Get PKC parameter k pointer in pkc sram.
Definition: ll_pkc.h:479
ll_pkc_enable_it_done
__STATIC_INLINE void ll_pkc_enable_it_done(pkc_regs_t *PKCx)
Enable the operation done interrupt.
Definition: ll_pkc.h:2185
ll_pkc_is_enable_it_err
__STATIC_INLINE uint32_t ll_pkc_is_enable_it_err(pkc_regs_t *PKCx)
Indicate whether the operation error interrupt is enable.
Definition: ll_pkc.h:2290
_ll_ecc_curve_init::G
ll_ecc_point_t G
Definition: ll_pkc.h:117
ll_pkc_is_enabled_random_clock_gating
__STATIC_INLINE uint32_t ll_pkc_is_enabled_random_clock_gating(pkc_regs_t *PKCx)
Indicate whether the Random Clock Gating in software mode is enabled.
Definition: ll_pkc.h:1467
ll_pkc_set_rsq_pointer
__STATIC_INLINE void ll_pkc_set_rsq_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R^2 pointer in pkc sram.
Definition: ll_pkc.h:557
ll_pkc_get_mi_u_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mi_u_pointer(pkc_regs_t *PKCx)
Get modular invertion parameter U pointer in pkc sram.
Definition: ll_pkc.h:1746
ll_pkc_set_tmp3_pointer
__STATIC_INLINE void ll_pkc_set_tmp3_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp3 pointer in pkc sram.
Definition: ll_pkc.h:929
ll_pkc_set_mas_a_pointer
__STATIC_INLINE void ll_pkc_set_mas_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular add/sub parameter A pointer in pkc sram.
Definition: ll_pkc.h:1607
_ll_ecc_point::Y
uint32_t Y[ECC_U32_LENGTH]
Definition: ll_pkc.h:95
ll_pkc_get_r0x_pointer
__STATIC_INLINE uint32_t ll_pkc_get_r0x_pointer(pkc_regs_t *PKCx)
Get PKC parameter R0x pointer in pkc sram.
Definition: ll_pkc.h:696
ll_pkc_get_mik_output
__STATIC_INLINE uint32_t ll_pkc_get_mik_output(pkc_regs_t *PKCx)
Get K output in invertion operation.
Definition: ll_pkc.h:1916
ll_pkc_set_r0y_pointer
__STATIC_INLINE void ll_pkc_set_r0y_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter R0y pointer in pkc sram.
Definition: ll_pkc.h:712
ll_pkc_is_enable_it_done
__STATIC_INLINE uint32_t ll_pkc_is_enable_it_done(pkc_regs_t *PKCx)
Indicate whether the operation done interrupt is enable.
Definition: ll_pkc.h:2275
ll_pkc_get_constant1_pointer
__STATIC_INLINE uint32_t ll_pkc_get_constant1_pointer(pkc_regs_t *PKCx)
Get PKC parameter Constant1 pointer in pkc sram.
Definition: ll_pkc.h:1068
ll_pkc_get_ecc_a_pointer
__STATIC_INLINE uint32_t ll_pkc_get_ecc_a_pointer(pkc_regs_t *PKCx)
Get ECC parameter A pointer in pkc sram.
Definition: ll_pkc.h:1223
ll_pkc_set_tmp6_pointer
__STATIC_INLINE void ll_pkc_set_tmp6_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Tmp6 pointer in pkc sram.
Definition: ll_pkc.h:1022
ll_pkc_enable_hardware_start
__STATIC_INLINE void ll_pkc_enable_hardware_start(pkc_regs_t *PKCx)
Enable pkc start in hardware mode.
Definition: ll_pkc.h:328
ll_pkc_get_mm_p_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mm_p_pointer(pkc_regs_t *PKCx)
Get modular multiplication parameter P pointer in pkc sram.
Definition: ll_pkc.h:1560
ll_pkc_enable_reset
__STATIC_INLINE void ll_pkc_enable_reset(pkc_regs_t *PKCx)
Enable pkc reset.
Definition: ll_pkc.h:418
ll_pkc_is_enabled_software_start
__STATIC_INLINE uint32_t ll_pkc_is_enabled_software_start(pkc_regs_t *PKCx)
Indicate whether the pkc start in software mode is enabled.
Definition: ll_pkc.h:1330
ll_pkc_is_enabled_software
__STATIC_INLINE uint32_t ll_pkc_is_enabled_software(pkc_regs_t *PKCx)
Indicate whether the pkc software mode is enabled.
Definition: ll_pkc.h:403
ll_pkc_disable_dummy_multi
__STATIC_INLINE void ll_pkc_disable_dummy_multi(pkc_regs_t *PKCx)
Disable Dummy Multi in software mode.
Definition: ll_pkc.h:1407
ll_pkc_set_p_pointer
__STATIC_INLINE void ll_pkc_set_p_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter p pointer in pkc sram.
Definition: ll_pkc.h:526
ll_pkc_set_gz_pointer
__STATIC_INLINE void ll_pkc_set_gz_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Gz pointer in pkc sram.
Definition: ll_pkc.h:650
ll_pkc_is_action_flag_it_err
__STATIC_INLINE uint32_t ll_pkc_is_action_flag_it_err(pkc_regs_t *PKCx)
Indicate whether the operation error interrupt is pending.
Definition: ll_pkc.h:2341
ll_pkc_set_mas_b_pointer
__STATIC_INLINE void ll_pkc_set_mas_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular add/sub parameter B pointer in pkc sram.
Definition: ll_pkc.h:1638
ll_pkc_disable_hardware_start
__STATIC_INLINE void ll_pkc_disable_hardware_start(pkc_regs_t *PKCx)
Disable pkc start in hardware mode.
Definition: ll_pkc.h:343
ll_pkc_set_ba_a_pointer
__STATIC_INLINE void ll_pkc_set_ba_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer operand A pointer in pkc sram.
Definition: ll_pkc.h:2056
ll_pkc_get_tmp3_pointer
__STATIC_INLINE uint32_t ll_pkc_get_tmp3_pointer(pkc_regs_t *PKCx)
Get PKC parameter Tmp3 pointer in pkc sram.
Definition: ll_pkc.h:944
_ll_ecc_curve_init::B
uint32_t B[ECC_U32_LENGTH]
Definition: ll_pkc.h:105
_ll_ecc_point::X
uint32_t X[ECC_U32_LENGTH]
Definition: ll_pkc.h:93
ll_pkc_enable_random_clock_gating
__STATIC_INLINE void ll_pkc_enable_random_clock_gating(pkc_regs_t *PKCx)
Enable Random Clock Gating in software mode.
Definition: ll_pkc.h:1437
_ll_ecc_curve_init::N
uint32_t N[ECC_U32_LENGTH]
Definition: ll_pkc.h:111
ll_pkc_clear_flag_it_big_add_overflow
__STATIC_INLINE void ll_pkc_clear_flag_it_big_add_overflow(pkc_regs_t *PKCx)
Clear the big integer overflow interrupt flag.
Definition: ll_pkc.h:2401
ll_pkc_set_ba_b_pointer
__STATIC_INLINE void ll_pkc_set_ba_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer operand B pointer in pkc sram.
Definition: ll_pkc.h:2087
ll_pkc_get_mas_a_pointer
__STATIC_INLINE uint32_t ll_pkc_get_mas_a_pointer(pkc_regs_t *PKCx)
Get modular add/sub parameter A pointer in pkc sram.
Definition: ll_pkc.h:1622
ll_pkc_enable_it_big_add_overflow
__STATIC_INLINE void ll_pkc_enable_it_big_add_overflow(pkc_regs_t *PKCx)
Enable the big integer overflow interrupt.
Definition: ll_pkc.h:2215
ll_pkc_set_constp
__STATIC_INLINE void ll_pkc_set_constp(pkc_regs_t *PKCx, uint32_t ConstP)
Set constant value for montgomery multiply in pkc sram.
Definition: ll_pkc.h:1270
ll_pkc_get_x1_pointer
__STATIC_INLINE uint32_t ll_pkc_get_x1_pointer(pkc_regs_t *PKCx)
Get PKC parameter X1 pointer in pkc sram.
Definition: ll_pkc.h:1099
ll_pkc_init_t
struct _ll_pkc_init ll_pkc_init_t
LL PKC Init Structure definition.
ll_pkc_set_gy_pointer
__STATIC_INLINE void ll_pkc_set_gy_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set PKC parameter Gy pointer in pkc sram.
Definition: ll_pkc.h:619
ll_pkc_set_ecc_a_pointer
__STATIC_INLINE void ll_pkc_set_ecc_a_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set ECC parameter A pointer in pkc sram.
Definition: ll_pkc.h:1208
ll_ecc_point_t
struct _ll_ecc_point ll_ecc_point_t
LL PKC ECC Point Structure definition.
ll_pkc_get_dummy_multiply_seed
__STATIC_INLINE uint32_t ll_pkc_get_dummy_multiply_seed(pkc_regs_t *PKCx)
Get dummy multiply seed.
Definition: ll_pkc.h:1947
ll_pkc_enable_software
__STATIC_INLINE void ll_pkc_enable_software(pkc_regs_t *PKCx)
Enable pkc software mode.
Definition: ll_pkc.h:373
ll_pkc_set_bm_b_pointer
__STATIC_INLINE void ll_pkc_set_bm_b_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set big integer operand B pointer in pkc sram.
Definition: ll_pkc.h:1994
ll_pkc_get_ba_b_pointer
__STATIC_INLINE uint32_t ll_pkc_get_ba_b_pointer(pkc_regs_t *PKCx)
Get big integer operand B pointer in pkc sram.
Definition: ll_pkc.h:2102
ll_pkc_set_mi_u_pointer
__STATIC_INLINE void ll_pkc_set_mi_u_pointer(pkc_regs_t *PKCx, uint32_t pointer)
Set modular invertion parameter U pointer in pkc sram.
Definition: ll_pkc.h:1731
ll_pkc_get_swmi_tmp_pointer
__STATIC_INLINE uint32_t ll_pkc_get_swmi_tmp_pointer(pkc_regs_t *PKCx)
Get modular invertion parameter Tmp pointer in pkc sram.
Definition: ll_pkc.h:1870
ll_pkc_set_operation_mode
__STATIC_INLINE void ll_pkc_set_operation_mode(pkc_regs_t *PKCx, uint32_t operation_mode)
Set operation mode in software mode.
Definition: ll_pkc.h:1354
_ll_ecc_curve_init::ConstN
uint32_t ConstN
Definition: ll_pkc.h:113