app_pkc.h
Go to the documentation of this file.
1 /**
2  ****************************************************************************************
3  *
4  * @file app_pkc.h
5  * @author BLE Driver Team
6  * @brief Header file containing functions prototypes of PKC app 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 APP_DRIVER APP DRIVER
43  * @{
44  */
45 
46 /** @defgroup APP_PKC PKC
47  * @brief PKC APP module driver.
48  * @{
49  */
50 
51 
52 #ifndef _APP_PKC_H_
53 #define _APP_PKC_H_
54 
55 #include "grx_hal.h"
56 #include "app_drv_error.h"
57 #include "app_drv_config.h"
58 
59 #ifdef __cplusplus
60 extern "C" {
61 #endif
62 
63 #ifdef HAL_PKC_MODULE_ENABLED
64 
65 /** @addtogroup APP_PKC_ENUM Enumerations
66  * @{
67  */
68 
69 /**
70  * @brief PKC operating mode Enumerations definition
71  */
72 typedef enum
73 {
74  APP_PKC_TYPE_INTERRUPT, /**< Interrupt operation mode. */
75  APP_PKC_TYPE_POLLING, /**< Polling operation mode. */
76  APP_PKC_TYPE_MAX /**< Only for check parameter, not used as input parameters. */
78 
79 
80 /**
81  * @brief PKC event Enumerations definition
82  */
83 typedef enum
84 {
85  APP_PKC_EVT_ERROR, /**< Error reported by PKC peripheral. */
86  APP_PKC_EVT_DONE /**< Encryption and decryption completed. */
88 /** @} */
89 
90 
91 /** @addtogroup APP_PKC_STRUCT Structures
92  * @{
93  */
94 
95 /**
96  * @brief PKC event structure definition
97  */
98 typedef struct
99 {
100  app_pkc_evt_type_t type; /**< Type of event. */
101  uint32_t error_code; /**< Error Code. */
102 } app_pkc_evt_t;
103 
104 /** @addtogroup APP_PKC_TYPEDEF Typedefs
105  * @{
106  */
107 typedef pkc_ecc_point_multi_t app_pkc_ecc_point_multi_t; /**< Pkc_ecc_point_multi_t typedef. */
108 typedef pkc_modular_add_t app_pkc_modular_add_t; /**< Pkc_modular_add_t typedef. */
109 typedef pkc_modular_sub_t app_pkc_modular_sub_t; /**< Pkc_modular_sub_t typedef. */
110 typedef pkc_modular_shift_t app_pkc_modular_shift_t; /**< Pkc_modular_shift_t typedef. */
111 typedef pkc_modular_compare_t app_pkc_modular_compare_t; /**< Pkc_modular_compare_t typedef. */
112 typedef pkc_montgomery_multi_t app_pkc_montgomery_multi_t; /**< Pkc_montgomery_multi_t typedef. */
113 typedef pkc_montgomery_inversion_t app_pkc_montgomery_inversion_t; /**< Pkc_montgomery_inversion_t typedef. */
114 typedef pkc_big_number_multi_t app_pkc_big_number_multi_t; /**< Pkc_big_number_multi_t typedef. */
115 typedef pkc_big_number_add_t app_pkc_big_number_add_t; /**< Pkc_big_number_add_t typedef. */
116 /** @} */
117 
118 /**
119  * @brief PKC event callback definition
120  */
121 typedef void (*app_pkc_evt_handler_t)(app_pkc_evt_t *p_evt);
122 
123 /**@brief App pkc state types. */
124 typedef enum
125 {
128 #ifdef APP_DRIVER_WAKEUP_CALL_FUN
129  APP_PKC_SLEEP,
130 #endif
132 
133 /**
134  * @brief PKC device structure definition
135  */
136 typedef struct
137 {
138  app_pkc_evt_handler_t evt_handler; /**< Pkc event callback. */
139  pkc_handle_t handle; /**< Pkc handle Structure. */
140  app_pkc_type_t ues_type; /**< Pkc operating mode Enumerations. */
141  app_pkc_state_t pkc_state; /**< App pkc state types. */
142 } pkc_env_t;
143 
144 /**
145  * @brief PKC parameters structure definition
146  */
147 typedef struct
148 {
149  app_pkc_type_t use_type; /**< Specifies the operation mode of PKC. */
150  pkc_init_t init; /**< PKC operation parameters */
151  void *p_result; /**< Pointer to PKC result Buffer */
152  uint32_t *p_kout; /**< Pointer to Kout result in montgomery inversion */
153  pkc_env_t pkc_env; /**< PKC device structure definition. */
155 
156 /** @} */
157 
158 /* Exported functions --------------------------------------------------------*/
159 /** @addtogroup APP_PKC_DRIVER_FUNCTIONS Functions
160  * @{
161  */
162 
163 /**
164  ****************************************************************************************
165  * @brief Initialize the APP PKC DRIVER according to the specified parameters
166  * in the app_pkc_params_t and app_pkc_evt_handler_t.
167  * @note If interrupt mode is set, you can use blocking mode. Conversely, if blocking mode
168  * is set, you can't use interrupt mode.
169  *
170  * @param[in] p_params: Pointer to app_pkc_params_t parameter which contains the
171  * configuration information for the specified PKC module.
172  * @param[in] evt_handler: PKC user callback function.
173  *
174  * @return Result of initialization.
175  ****************************************************************************************
176  */
177 uint16_t app_pkc_init(app_pkc_params_t *p_params, app_pkc_evt_handler_t evt_handler);
178 
179 /**
180  ****************************************************************************************
181  * @brief De-initialize the APP PKC DRIVER peripheral.
182  *
183  * @return Result of De-initialization.
184  ****************************************************************************************
185  */
186 uint16_t app_pkc_deinit(void);
187 /**
188  ****************************************************************************************
189  * @brief Realize the point multiplication operation of ECC ellipse algorithm锛�: result = k * point锛孭olling mode
190  *
191  * @param[in] p_input: pointer to the input parameter pkc_ecc_point_multi_t structure variable.
192  * @param[in] timeout: Timeout duration
193  *
194  * @return Result of operation.
195  ****************************************************************************************
196  */
197 uint16_t app_pkc_ecc_point_multi_sync(app_pkc_ecc_point_multi_t *p_input, uint32_t timeout);
198 /**
199  ****************************************************************************************
200  * @brief Realize the point multiplication operation of ECC ellipse algorithm锛�: result = k * point锛孖nterrupt mode
201  *
202  * @param[in] p_input: pointer to the input parameter pkc_ecc_point_multi_t structure variable.
203  *
204  * @return Result of operation.
205  ****************************************************************************************
206  */
208 /**
209  ****************************************************************************************
210  * @brief Realization of modular addition: result = (A + B) mod P锛孭olling mode
211  *
212  * @param[in] p_input: pointer to the input parameter pkc_modular_add_t structure variable.
213  * @param[in] timeout: Timeout duration
214  *
215  * @return Result of operation.
216  ****************************************************************************************
217  */
218 uint16_t app_pkc_modular_add_sync(app_pkc_modular_add_t *p_input, uint32_t timeout);
219 /**
220  ****************************************************************************************
221  * @brief Realization of modular addition: result = (A + B) mod P锛孖nterrupt mode
222  *
223  * @param[in] p_input: pointer to the input parameter pkc_modular_add_t structure variable.
224  *
225  * @return Result of operation.
226  ****************************************************************************************
227  */
229 /**
230  ****************************************************************************************
231  * @brief Implementation of modular subtraction: result = (A - B) mod P锛孭olling mode
232  *
233  * @param[in] p_input: pointer to the input parameter pkc_modular_sub_t structure variable.
234  * @param[in] timeout: Timeout duration
235  *
236  * @return Result of operation.
237  ****************************************************************************************
238  */
239 uint16_t app_pkc_modular_sub_sync(app_pkc_modular_sub_t *p_input, uint32_t timeout);
240 /**
241  ****************************************************************************************
242  * @brief Implementation of modular subtraction: result = (A - B) mod P锛孖nterrupt mode
243  *
244  * @param[in] p_input: pointer to the input parameter pkc_modular_sub_t structure variable.
245  *
246  * @return Result of operation.
247  ****************************************************************************************
248  */
250 /**
251  ****************************************************************************************
252  * @brief Realization of module shift left operation: result = (A<<ShiftBits) mod P锛孭olling mode
253  *
254  * @param[in] p_input: pointer to the input parameter pkc_modular_shift_t structure variable.
255  * @param[in] timeout: Timeout duration
256  *
257  * @return Result of operation.
258  ****************************************************************************************
259  */
260 uint16_t app_pkc_modular_left_shift_sync(app_pkc_modular_shift_t *p_input, uint32_t timeout);
261 /**
262  ****************************************************************************************
263  * @brief Realization of module shift left operation: result = (A<<ShiftBits) mod P锛孖nterrupt mode
264  *
265  * @param[in] p_input: pointer to the input parameter pkc_modular_shift_t structure variable.
266  *
267  * @return Result of operation.
268  ****************************************************************************************
269  */
271 /**
272  ****************************************************************************************
273  * @brief Realization of modular comparison operation: result = A mod P锛孭olling mode
274  *
275  * @param[in] p_input: pointer to the input parameter pkc_modular_compare_t structure variable.
276  * @param[in] timeout: Timeout duration
277  *
278  * @return Result of operation.
279  ****************************************************************************************
280  */
281 uint16_t app_pkc_modular_compare_sync(app_pkc_modular_compare_t *p_input, uint32_t timeout);
282 /**
283  ****************************************************************************************
284  * @brief Realization of modular comparison operation: result = A mod P锛孖nterrupt mode
285  *
286  * @param[in] p_input: pointer to the input parameter pkc_modular_compare_t structure variable.
287  *
288  * @return Result of operation.
289  ****************************************************************************************
290  */
292 /**
293  ****************************************************************************************
294  * @brief Realization of modular multiplication: result = A*B mod P锛孭olling mode
295  *
296  * @param[in] p_input: pointer to the input parameter pkc_montgomery_multi_t structure variable.
297  * @param[in] timeout: Timeout duration
298  *
299  * @return Result of operation.
300  ****************************************************************************************
301  */
302 uint16_t app_pkc_montgomery_multi_sync(app_pkc_montgomery_multi_t *p_input, uint32_t timeout);
303 /**
304  ****************************************************************************************
305  * @brief Realization of modular multiplication: result = A*B mod P锛孖nterrupt mode
306  *
307  * @param[in] p_input: pointer to the input parameter pkc_montgomery_multi_t structure variable.
308  *
309  * @return Result of operation.
310  ****************************************************************************************
311  */
313 /**
314  ****************************************************************************************
315  * @brief Realization of modular inversion: result = A^(-1)mod P锛孭olling mode
316  *
317  * @param[in] p_input: pointer to the input parameter pkc_montgomery_inversion_t structure variable.
318  * @param[in] timeout: Timeout duration
319  *
320  * @return Result of operation.
321  ****************************************************************************************
322  */
324 /**
325  ****************************************************************************************
326  * @brief Realization of modular inversion: result = A^(-1)mod P锛孖nterrupt mode
327  *
328  * @param[in] p_input: pointer to the input parameter pkc_montgomery_inversion_t structure variable.
329  *
330  * @return Result of operation.
331  ****************************************************************************************
332  */
334 /**
335  ****************************************************************************************
336  * @brief Realize multiplication of large numbers: result = A*B锛孭olling mode
337  *
338  * @param[in] p_input: pointer to the input parameter pkc_big_number_multi_t structure variable.
339  * @param[in] timeout: Timeout duration
340  *
341  * @return Result of operation.
342  ****************************************************************************************
343  */
344 uint16_t app_pkc_big_number_multi_sync(app_pkc_big_number_multi_t *p_input, uint32_t timeout);
345 /**
346  ****************************************************************************************
347  * @brief Realize multiplication of large numbers: result = A*B锛孖nterrupt mode
348  *
349  * @param[in] p_input: pointer to the input parameter pkc_big_number_multi_t structure variable.
350  *
351  * @return Result of operation.
352  ****************************************************************************************
353  */
355 /**
356  ****************************************************************************************
357  * @brief Realize addition of large numbers: result = A+B锛孭olling mode
358  *
359  * @param[in] p_input: pointer to the input parameter pkc_big_number_add_t structure variable.
360  * @param[in] timeout: Timeout duration
361  *
362  * @return Result of operation.
363  ****************************************************************************************
364  */
365 uint16_t app_pkc_big_number_add_sync(app_pkc_big_number_add_t *p_input, uint32_t timeout);
366 /**
367  ****************************************************************************************
368  * @brief Realize addition of large numbers: result = A+B锛孖nterrupt mode
369  *
370  * @param[in] p_input: pointer to the input parameter pkc_big_number_add_t structure variable.
371  *
372  * @return Result of operation.
373  ****************************************************************************************
374  */
376 
377 /**
378  ****************************************************************************************
379  * @brief Return the PKC handle.
380  *
381  * @return Pointer to the PKC handle.
382  ****************************************************************************************
383  */
385 
386 /** @} */
387 
388 #endif
389 
390 #ifdef __cplusplus
391 }
392 #endif
393 
394 #endif
395 
396 /** @} */
397 /** @} */
398 /** @} */
APP_PKC_ACTIVITY
@ APP_PKC_ACTIVITY
Definition: app_pkc.h:127
app_pkc_ecc_point_multi_sync
uint16_t app_pkc_ecc_point_multi_sync(app_pkc_ecc_point_multi_t *p_input, uint32_t timeout)
Realize the point multiplication operation of ECC ellipse algorithm锛�: result = k * point锛孭olling mod...
app_pkc_params_t::use_type
app_pkc_type_t use_type
Definition: app_pkc.h:149
_pkc_montgomery_multi
PKC Montgomery Modular Multiplication expression input.
Definition: gr55xx_hal_pkc.h:233
_pkc_montgomery_inversion
PKC Montgomery Inversion expression input.
Definition: gr55xx_hal_pkc.h:246
app_pkc_modular_compare_async
uint16_t app_pkc_modular_compare_async(app_pkc_modular_compare_t *p_input)
Realization of modular comparison operation: result = A mod P锛孖nterrupt mode.
_pkc_modular_shift
PKC Modular Left Shift expression input.
Definition: gr55xx_hal_pkc.h:212
app_pkc_init
uint16_t app_pkc_init(app_pkc_params_t *p_params, app_pkc_evt_handler_t evt_handler)
Initialize the APP PKC DRIVER according to the specified parameters in the app_pkc_params_t and app_p...
pkc_env_t::pkc_state
app_pkc_state_t pkc_state
Definition: app_pkc.h:141
pkc_env_t::handle
pkc_handle_t handle
Definition: app_pkc.h:139
app_pkc_big_number_add_t
pkc_big_number_add_t app_pkc_big_number_add_t
Definition: app_pkc.h:115
app_pkc_modular_shift_t
pkc_modular_shift_t app_pkc_modular_shift_t
Definition: app_pkc.h:110
APP_PKC_TYPE_MAX
@ APP_PKC_TYPE_MAX
Definition: app_pkc.h:76
app_pkc_montgomery_multi_async
uint16_t app_pkc_montgomery_multi_async(app_pkc_montgomery_multi_t *p_input)
Realization of modular multiplication: result = A*B mod P锛孖nterrupt mode.
app_pkc_big_number_add_async
uint16_t app_pkc_big_number_add_async(app_pkc_big_number_add_t *p_input)
Realize addition of large numbers: result = A+B锛孖nterrupt mode.
_pkc_modular_compare
PKC Modular Comparison expression input.
Definition: gr55xx_hal_pkc.h:223
app_pkc_params_t::init
pkc_init_t init
Definition: app_pkc.h:150
_pkc_handle
PKC handle Structure definition.
Definition: gr55xx_hal_pkc.h:134
app_pkc_params_t::p_kout
uint32_t * p_kout
Definition: app_pkc.h:152
pkc_env_t::ues_type
app_pkc_type_t ues_type
Definition: app_pkc.h:140
_pkc_big_number_add
PKC Big Number Addition expression input.
Definition: gr55xx_hal_pkc.h:268
app_pkc_evt_t::error_code
uint32_t error_code
Definition: app_pkc.h:101
app_pkc_modular_left_shift_sync
uint16_t app_pkc_modular_left_shift_sync(app_pkc_modular_shift_t *p_input, uint32_t timeout)
Realization of module shift left operation: result = (A<<ShiftBits) mod P锛孭olling mode.
pkc_env_t::evt_handler
app_pkc_evt_handler_t evt_handler
Definition: app_pkc.h:138
app_pkc_modular_add_t
pkc_modular_add_t app_pkc_modular_add_t
Definition: app_pkc.h:108
app_pkc_montgomery_inversion_t
pkc_montgomery_inversion_t app_pkc_montgomery_inversion_t
Definition: app_pkc.h:113
app_pkc_big_number_multi_sync
uint16_t app_pkc_big_number_multi_sync(app_pkc_big_number_multi_t *p_input, uint32_t timeout)
Realize multiplication of large numbers: result = A*B锛孭olling mode.
app_pkc_type_t
app_pkc_type_t
PKC operating mode Enumerations definition.
Definition: app_pkc.h:73
app_pkc_montgomery_inversion_sync
uint16_t app_pkc_montgomery_inversion_sync(app_pkc_montgomery_inversion_t *p_input, uint32_t timeout)
Realization of modular inversion: result = A^(-1)mod P锛孭olling mode.
APP_PKC_TYPE_POLLING
@ APP_PKC_TYPE_POLLING
Definition: app_pkc.h:75
pkc_init_t
PKC Init Structure definition.
Definition: gr55xx_hal_pkc.h:111
app_pkc_evt_type_t
app_pkc_evt_type_t
PKC event Enumerations definition.
Definition: app_pkc.h:84
_pkc_modular_sub
PKC Modular Subtraction expression input.
Definition: gr55xx_hal_pkc.h:201
app_pkc_big_number_multi_async
uint16_t app_pkc_big_number_multi_async(app_pkc_big_number_multi_t *p_input)
Realize multiplication of large numbers: result = A*B锛孖nterrupt mode.
grx_hal.h
This file contains all the functions prototypes for the HAL module driver.
app_pkc_big_number_add_sync
uint16_t app_pkc_big_number_add_sync(app_pkc_big_number_add_t *p_input, uint32_t timeout)
Realize addition of large numbers: result = A+B锛孭olling mode.
app_pkc_montgomery_inversion_async
uint16_t app_pkc_montgomery_inversion_async(app_pkc_montgomery_inversion_t *p_input)
Realization of modular inversion: result = A^(-1)mod P锛孖nterrupt mode.
APP_PKC_EVT_ERROR
@ APP_PKC_EVT_ERROR
Definition: app_pkc.h:85
app_pkc_montgomery_multi_sync
uint16_t app_pkc_montgomery_multi_sync(app_pkc_montgomery_multi_t *p_input, uint32_t timeout)
Realization of modular multiplication: result = A*B mod P锛孭olling mode.
app_pkc_modular_sub_t
pkc_modular_sub_t app_pkc_modular_sub_t
Definition: app_pkc.h:109
app_pkc_params_t::pkc_env
pkc_env_t pkc_env
Definition: app_pkc.h:153
app_pkc_ecc_point_multi_async
uint16_t app_pkc_ecc_point_multi_async(app_pkc_ecc_point_multi_t *p_input)
Realize the point multiplication operation of ECC ellipse algorithm锛�: result = k * point锛孖nterrupt m...
app_pkc_montgomery_multi_t
pkc_montgomery_multi_t app_pkc_montgomery_multi_t
Definition: app_pkc.h:112
_pkc_ecc_point_multi
PKC ECC Point Multiplication expression input.
Definition: gr55xx_hal_pkc.h:166
app_pkc_state_t
app_pkc_state_t
App pkc state types.
Definition: app_pkc.h:125
app_pkc_modular_left_shift_async
uint16_t app_pkc_modular_left_shift_async(app_pkc_modular_shift_t *p_input)
Realization of module shift left operation: result = (A<<ShiftBits) mod P锛孖nterrupt mode.
app_pkc_params_t::p_result
void * p_result
Definition: app_pkc.h:151
app_pkc_modular_add_async
uint16_t app_pkc_modular_add_async(app_pkc_modular_add_t *p_input)
Realization of modular addition: result = (A + B) mod P锛孖nterrupt mode.
app_pkc_deinit
uint16_t app_pkc_deinit(void)
De-initialize the APP PKC DRIVER peripheral.
app_pkc_ecc_point_multi_t
pkc_ecc_point_multi_t app_pkc_ecc_point_multi_t
Definition: app_pkc.h:107
APP_PKC_TYPE_INTERRUPT
@ APP_PKC_TYPE_INTERRUPT
Definition: app_pkc.h:74
pkc_env_t
PKC device structure definition.
Definition: app_pkc.h:137
_pkc_modular_add
PKC Modular Addition expression input.
Definition: gr55xx_hal_pkc.h:190
_pkc_big_number_multi
PKC Big Number Multiplication expression input.
Definition: gr55xx_hal_pkc.h:258
app_pkc_modular_sub_async
uint16_t app_pkc_modular_sub_async(app_pkc_modular_sub_t *p_input)
Implementation of modular subtraction: result = (A - B) mod P锛孖nterrupt mode.
app_pkc_params_t
PKC parameters structure definition.
Definition: app_pkc.h:148
app_pkc_get_handle
pkc_handle_t * app_pkc_get_handle(void)
Return the PKC handle.
app_pkc_big_number_multi_t
pkc_big_number_multi_t app_pkc_big_number_multi_t
Definition: app_pkc.h:114
app_pkc_modular_compare_sync
uint16_t app_pkc_modular_compare_sync(app_pkc_modular_compare_t *p_input, uint32_t timeout)
Realization of modular comparison operation: result = A mod P锛孭olling mode.
app_pkc_evt_t
PKC event structure definition.
Definition: app_pkc.h:99
app_drv_error.h
Header file of app driver error code.
APP_PKC_INVALID
@ APP_PKC_INVALID
Definition: app_pkc.h:126
APP_PKC_EVT_DONE
@ APP_PKC_EVT_DONE
Definition: app_pkc.h:86
app_drv_config.h
Header file of app driver config code.
app_pkc_modular_add_sync
uint16_t app_pkc_modular_add_sync(app_pkc_modular_add_t *p_input, uint32_t timeout)
Realization of modular addition: result = (A + B) mod P锛孭olling mode.
app_pkc_evt_t::type
app_pkc_evt_type_t type
Definition: app_pkc.h:100
app_pkc_modular_sub_sync
uint16_t app_pkc_modular_sub_sync(app_pkc_modular_sub_t *p_input, uint32_t timeout)
Implementation of modular subtraction: result = (A - B) mod P锛孭olling mode.
app_pkc_evt_handler_t
void(* app_pkc_evt_handler_t)(app_pkc_evt_t *p_evt)
PKC event callback definition.
Definition: app_pkc.h:121
app_pkc_modular_compare_t
pkc_modular_compare_t app_pkc_modular_compare_t
Definition: app_pkc.h:111