]>
Commit | Line | Data |
---|---|---|
9f95a23c TL |
1 | /* SPDX-License-Identifier: BSD-3-Clause |
2 | * Copyright(c) 2015-2016 Intel Corporation. | |
7c673cae FG |
3 | */ |
4 | ||
5 | #ifndef _RTE_CRYPTODEV_PMD_H_ | |
6 | #define _RTE_CRYPTODEV_PMD_H_ | |
7 | ||
8 | /** @file | |
9 | * RTE Crypto PMD APIs | |
10 | * | |
11 | * @note | |
12 | * These API are from crypto PMD only and user applications should not call | |
13 | * them directly. | |
14 | */ | |
15 | ||
16 | #ifdef __cplusplus | |
17 | extern "C" { | |
18 | #endif | |
19 | ||
20 | #include <string.h> | |
21 | ||
9f95a23c | 22 | #include <rte_config.h> |
7c673cae | 23 | #include <rte_dev.h> |
7c673cae FG |
24 | #include <rte_malloc.h> |
25 | #include <rte_mbuf.h> | |
26 | #include <rte_mempool.h> | |
27 | #include <rte_log.h> | |
28 | #include <rte_common.h> | |
29 | ||
30 | #include "rte_crypto.h" | |
31 | #include "rte_cryptodev.h" | |
32 | ||
7c673cae | 33 | |
9f95a23c | 34 | #define RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS 8 |
7c673cae | 35 | |
9f95a23c TL |
36 | #define RTE_CRYPTODEV_PMD_NAME_ARG ("name") |
37 | #define RTE_CRYPTODEV_PMD_MAX_NB_QP_ARG ("max_nb_queue_pairs") | |
38 | #define RTE_CRYPTODEV_PMD_SOCKET_ID_ARG ("socket_id") | |
7c673cae | 39 | |
7c673cae | 40 | |
9f95a23c TL |
41 | static const char * const cryptodev_pmd_valid_params[] = { |
42 | RTE_CRYPTODEV_PMD_NAME_ARG, | |
43 | RTE_CRYPTODEV_PMD_MAX_NB_QP_ARG, | |
44 | RTE_CRYPTODEV_PMD_SOCKET_ID_ARG | |
45 | }; | |
7c673cae FG |
46 | |
47 | /** | |
9f95a23c TL |
48 | * @internal |
49 | * Initialisation parameters for crypto devices | |
7c673cae | 50 | */ |
9f95a23c TL |
51 | struct rte_cryptodev_pmd_init_params { |
52 | char name[RTE_CRYPTODEV_NAME_MAX_LEN]; | |
53 | size_t private_data_size; | |
54 | int socket_id; | |
55 | unsigned int max_nb_queue_pairs; | |
7c673cae FG |
56 | }; |
57 | ||
7c673cae FG |
58 | /** Global structure used for maintaining state of allocated crypto devices */ |
59 | struct rte_cryptodev_global { | |
60 | struct rte_cryptodev *devs; /**< Device information array */ | |
61 | struct rte_cryptodev_data *data[RTE_CRYPTO_MAX_DEVS]; | |
62 | /**< Device private data */ | |
63 | uint8_t nb_devs; /**< Number of devices found */ | |
64 | uint8_t max_devs; /**< Max number of devices */ | |
65 | }; | |
66 | ||
9f95a23c TL |
67 | /* Cryptodev driver, containing the driver ID */ |
68 | struct cryptodev_driver { | |
69 | TAILQ_ENTRY(cryptodev_driver) next; /**< Next in list. */ | |
70 | const struct rte_driver *driver; | |
71 | uint8_t id; | |
72 | }; | |
7c673cae FG |
73 | |
74 | /** | |
75 | * Get the rte_cryptodev structure device pointer for the device. Assumes a | |
76 | * valid device index. | |
77 | * | |
78 | * @param dev_id Device ID value to select the device structure. | |
79 | * | |
80 | * @return | |
81 | * - The rte_cryptodev structure pointer for the given device ID. | |
82 | */ | |
11fdf7f2 TL |
83 | struct rte_cryptodev * |
84 | rte_cryptodev_pmd_get_dev(uint8_t dev_id); | |
7c673cae FG |
85 | |
86 | /** | |
87 | * Get the rte_cryptodev structure device pointer for the named device. | |
88 | * | |
89 | * @param name device name to select the device structure. | |
90 | * | |
91 | * @return | |
92 | * - The rte_cryptodev structure pointer for the given device ID. | |
93 | */ | |
11fdf7f2 TL |
94 | struct rte_cryptodev * |
95 | rte_cryptodev_pmd_get_named_dev(const char *name); | |
7c673cae FG |
96 | |
97 | /** | |
98 | * Validate if the crypto device index is valid attached crypto device. | |
99 | * | |
100 | * @param dev_id Crypto device index. | |
101 | * | |
102 | * @return | |
103 | * - If the device index is valid (1) or not (0). | |
104 | */ | |
11fdf7f2 TL |
105 | unsigned int |
106 | rte_cryptodev_pmd_is_valid_dev(uint8_t dev_id); | |
7c673cae FG |
107 | |
108 | /** | |
109 | * The pool of rte_cryptodev structures. | |
110 | */ | |
111 | extern struct rte_cryptodev *rte_cryptodevs; | |
112 | ||
113 | ||
114 | /** | |
115 | * Definitions of all functions exported by a driver through the | |
116 | * the generic structure of type *crypto_dev_ops* supplied in the | |
117 | * *rte_cryptodev* structure associated with a device. | |
118 | */ | |
119 | ||
120 | /** | |
121 | * Function used to configure device. | |
122 | * | |
123 | * @param dev Crypto device pointer | |
11fdf7f2 | 124 | * config Crypto device configurations |
7c673cae FG |
125 | * |
126 | * @return Returns 0 on success | |
127 | */ | |
11fdf7f2 TL |
128 | typedef int (*cryptodev_configure_t)(struct rte_cryptodev *dev, |
129 | struct rte_cryptodev_config *config); | |
7c673cae FG |
130 | |
131 | /** | |
132 | * Function used to start a configured device. | |
133 | * | |
134 | * @param dev Crypto device pointer | |
135 | * | |
136 | * @return Returns 0 on success | |
137 | */ | |
138 | typedef int (*cryptodev_start_t)(struct rte_cryptodev *dev); | |
139 | ||
140 | /** | |
141 | * Function used to stop a configured device. | |
142 | * | |
143 | * @param dev Crypto device pointer | |
144 | */ | |
145 | typedef void (*cryptodev_stop_t)(struct rte_cryptodev *dev); | |
146 | ||
147 | /** | |
148 | * Function used to close a configured device. | |
149 | * | |
150 | * @param dev Crypto device pointer | |
151 | * @return | |
152 | * - 0 on success. | |
153 | * - EAGAIN if can't close as device is busy | |
154 | */ | |
155 | typedef int (*cryptodev_close_t)(struct rte_cryptodev *dev); | |
156 | ||
157 | ||
158 | /** | |
159 | * Function used to get statistics of a device. | |
160 | * | |
161 | * @param dev Crypto device pointer | |
162 | * @param stats Pointer to crypto device stats structure to populate | |
163 | */ | |
164 | typedef void (*cryptodev_stats_get_t)(struct rte_cryptodev *dev, | |
165 | struct rte_cryptodev_stats *stats); | |
166 | ||
167 | ||
168 | /** | |
169 | * Function used to reset statistics of a device. | |
170 | * | |
171 | * @param dev Crypto device pointer | |
172 | */ | |
173 | typedef void (*cryptodev_stats_reset_t)(struct rte_cryptodev *dev); | |
174 | ||
175 | ||
176 | /** | |
177 | * Function used to get specific information of a device. | |
178 | * | |
179 | * @param dev Crypto device pointer | |
180 | */ | |
181 | typedef void (*cryptodev_info_get_t)(struct rte_cryptodev *dev, | |
182 | struct rte_cryptodev_info *dev_info); | |
183 | ||
7c673cae FG |
184 | /** |
185 | * Setup a queue pair for a device. | |
186 | * | |
187 | * @param dev Crypto device pointer | |
188 | * @param qp_id Queue Pair Index | |
189 | * @param qp_conf Queue configuration structure | |
190 | * @param socket_id Socket Index | |
191 | * | |
192 | * @return Returns 0 on success. | |
193 | */ | |
194 | typedef int (*cryptodev_queue_pair_setup_t)(struct rte_cryptodev *dev, | |
195 | uint16_t qp_id, const struct rte_cryptodev_qp_conf *qp_conf, | |
196 | int socket_id); | |
197 | ||
198 | /** | |
199 | * Release memory resources allocated by given queue pair. | |
200 | * | |
201 | * @param dev Crypto device pointer | |
202 | * @param qp_id Queue Pair Index | |
203 | * | |
204 | * @return | |
205 | * - 0 on success. | |
206 | * - EAGAIN if can't close as device is busy | |
207 | */ | |
208 | typedef int (*cryptodev_queue_pair_release_t)(struct rte_cryptodev *dev, | |
209 | uint16_t qp_id); | |
210 | ||
211 | /** | |
212 | * Get number of available queue pairs of a device. | |
213 | * | |
214 | * @param dev Crypto device pointer | |
215 | * | |
216 | * @return Returns number of queue pairs on success. | |
217 | */ | |
218 | typedef uint32_t (*cryptodev_queue_pair_count_t)(struct rte_cryptodev *dev); | |
219 | ||
220 | /** | |
221 | * Create a session mempool to allocate sessions from | |
222 | * | |
223 | * @param dev Crypto device pointer | |
224 | * @param nb_objs number of sessions objects in mempool | |
225 | * @param obj_cache l-core object cache size, see *rte_ring_create* | |
226 | * @param socket_id Socket Id to allocate mempool on. | |
227 | * | |
228 | * @return | |
229 | * - On success returns a pointer to a rte_mempool | |
230 | * - On failure returns a NULL pointer | |
231 | */ | |
232 | typedef int (*cryptodev_sym_create_session_pool_t)( | |
233 | struct rte_cryptodev *dev, unsigned nb_objs, | |
234 | unsigned obj_cache_size, int socket_id); | |
235 | ||
236 | ||
237 | /** | |
238 | * Get the size of a cryptodev session | |
239 | * | |
240 | * @param dev Crypto device pointer | |
241 | * | |
242 | * @return | |
243 | * - On success returns the size of the session structure for device | |
244 | * - On failure returns 0 | |
245 | */ | |
246 | typedef unsigned (*cryptodev_sym_get_session_private_size_t)( | |
247 | struct rte_cryptodev *dev); | |
7c673cae | 248 | /** |
9f95a23c | 249 | * Get the size of a asymmetric cryptodev session |
7c673cae FG |
250 | * |
251 | * @param dev Crypto device pointer | |
7c673cae FG |
252 | * |
253 | * @return | |
9f95a23c TL |
254 | * - On success returns the size of the session structure for device |
255 | * - On failure returns 0 | |
7c673cae | 256 | */ |
9f95a23c TL |
257 | typedef unsigned int (*cryptodev_asym_get_session_private_size_t)( |
258 | struct rte_cryptodev *dev); | |
7c673cae FG |
259 | |
260 | /** | |
261 | * Configure a Crypto session on a device. | |
262 | * | |
263 | * @param dev Crypto device pointer | |
264 | * @param xform Single or chain of crypto xforms | |
265 | * @param priv_sess Pointer to cryptodev's private session structure | |
9f95a23c | 266 | * @param mp Mempool where the private session is allocated |
7c673cae FG |
267 | * |
268 | * @return | |
9f95a23c TL |
269 | * - Returns 0 if private session structure have been created successfully. |
270 | * - Returns -EINVAL if input parameters are invalid. | |
271 | * - Returns -ENOTSUP if crypto device does not support the crypto transform. | |
272 | * - Returns -ENOMEM if the private session could not be allocated. | |
7c673cae | 273 | */ |
9f95a23c TL |
274 | typedef int (*cryptodev_sym_configure_session_t)(struct rte_cryptodev *dev, |
275 | struct rte_crypto_sym_xform *xform, | |
276 | struct rte_cryptodev_sym_session *session, | |
277 | struct rte_mempool *mp); | |
7c673cae | 278 | /** |
9f95a23c TL |
279 | * Configure a Crypto asymmetric session on a device. |
280 | * | |
281 | * @param dev Crypto device pointer | |
282 | * @param xform Single or chain of crypto xforms | |
283 | * @param priv_sess Pointer to cryptodev's private session structure | |
284 | * @param mp Mempool where the private session is allocated | |
285 | * | |
286 | * @return | |
287 | * - Returns 0 if private session structure have been created successfully. | |
288 | * - Returns -EINVAL if input parameters are invalid. | |
289 | * - Returns -ENOTSUP if crypto device does not support the crypto transform. | |
290 | * - Returns -ENOMEM if the private session could not be allocated. | |
7c673cae | 291 | */ |
9f95a23c TL |
292 | typedef int (*cryptodev_asym_configure_session_t)(struct rte_cryptodev *dev, |
293 | struct rte_crypto_asym_xform *xform, | |
294 | struct rte_cryptodev_asym_session *session, | |
295 | struct rte_mempool *mp); | |
11fdf7f2 | 296 | /** |
9f95a23c TL |
297 | * Free driver private session data. |
298 | * | |
11fdf7f2 | 299 | * @param dev Crypto device pointer |
9f95a23c | 300 | * @param sess Cryptodev session structure |
11fdf7f2 | 301 | */ |
9f95a23c TL |
302 | typedef void (*cryptodev_sym_free_session_t)(struct rte_cryptodev *dev, |
303 | struct rte_cryptodev_sym_session *sess); | |
11fdf7f2 | 304 | /** |
9f95a23c TL |
305 | * Free asymmetric session private data. |
306 | * | |
11fdf7f2 | 307 | * @param dev Crypto device pointer |
9f95a23c | 308 | * @param sess Cryptodev session structure |
11fdf7f2 | 309 | */ |
9f95a23c TL |
310 | typedef void (*cryptodev_asym_free_session_t)(struct rte_cryptodev *dev, |
311 | struct rte_cryptodev_asym_session *sess); | |
7c673cae FG |
312 | |
313 | /** Crypto device operations function pointer table */ | |
314 | struct rte_cryptodev_ops { | |
315 | cryptodev_configure_t dev_configure; /**< Configure device. */ | |
316 | cryptodev_start_t dev_start; /**< Start device. */ | |
317 | cryptodev_stop_t dev_stop; /**< Stop device. */ | |
318 | cryptodev_close_t dev_close; /**< Close device. */ | |
319 | ||
320 | cryptodev_info_get_t dev_infos_get; /**< Get device info. */ | |
321 | ||
322 | cryptodev_stats_get_t stats_get; | |
323 | /**< Get device statistics. */ | |
324 | cryptodev_stats_reset_t stats_reset; | |
325 | /**< Reset device statistics. */ | |
326 | ||
327 | cryptodev_queue_pair_setup_t queue_pair_setup; | |
328 | /**< Set up a device queue pair. */ | |
329 | cryptodev_queue_pair_release_t queue_pair_release; | |
330 | /**< Release a queue pair. */ | |
7c673cae FG |
331 | cryptodev_queue_pair_count_t queue_pair_count; |
332 | /**< Get count of the queue pairs. */ | |
333 | ||
9f95a23c | 334 | cryptodev_sym_get_session_private_size_t sym_session_get_size; |
7c673cae | 335 | /**< Return private session. */ |
9f95a23c TL |
336 | cryptodev_asym_get_session_private_size_t asym_session_get_size; |
337 | /**< Return asym session private size. */ | |
338 | cryptodev_sym_configure_session_t sym_session_configure; | |
7c673cae | 339 | /**< Configure a Crypto session. */ |
9f95a23c TL |
340 | cryptodev_asym_configure_session_t asym_session_configure; |
341 | /**< Configure asymmetric Crypto session. */ | |
342 | cryptodev_sym_free_session_t sym_session_clear; | |
343 | /**< Clear a Crypto sessions private data. */ | |
344 | cryptodev_asym_free_session_t asym_session_clear; | |
7c673cae FG |
345 | /**< Clear a Crypto sessions private data. */ |
346 | }; | |
347 | ||
348 | ||
349 | /** | |
350 | * Function for internal use by dummy drivers primarily, e.g. ring-based | |
351 | * driver. | |
352 | * Allocates a new cryptodev slot for an crypto device and returns the pointer | |
353 | * to that slot for the driver to use. | |
354 | * | |
355 | * @param name Unique identifier name for each device | |
356 | * @param socket_id Socket to allocate resources on. | |
357 | * @return | |
358 | * - Slot in the rte_dev_devices array for a new device; | |
359 | */ | |
360 | struct rte_cryptodev * | |
361 | rte_cryptodev_pmd_allocate(const char *name, int socket_id); | |
362 | ||
7c673cae FG |
363 | /** |
364 | * Function for internal use by dummy drivers primarily, e.g. ring-based | |
365 | * driver. | |
366 | * Release the specified cryptodev device. | |
367 | * | |
368 | * @param cryptodev | |
369 | * The *cryptodev* pointer is the address of the *rte_cryptodev* structure. | |
370 | * @return | |
371 | * - 0 on success, negative on error | |
372 | */ | |
373 | extern int | |
374 | rte_cryptodev_pmd_release_device(struct rte_cryptodev *cryptodev); | |
375 | ||
9f95a23c TL |
376 | |
377 | /** | |
378 | * @internal | |
379 | * | |
380 | * PMD assist function to parse initialisation arguments for crypto driver | |
381 | * when creating a new crypto PMD device instance. | |
382 | * | |
383 | * PMD driver should set default values for that PMD before calling function, | |
384 | * these default values will be over-written with successfully parsed values | |
385 | * from args string. | |
386 | * | |
387 | * @param params parsed PMD initialisation parameters | |
388 | * @param args input argument string to parse | |
389 | * | |
390 | * @return | |
391 | * - 0 on success | |
392 | * - errno on failure | |
393 | */ | |
394 | int | |
395 | rte_cryptodev_pmd_parse_input_args( | |
396 | struct rte_cryptodev_pmd_init_params *params, | |
397 | const char *args); | |
398 | ||
399 | /** | |
400 | * @internal | |
401 | * | |
402 | * PMD assist function to provide boiler plate code for crypto driver to create | |
403 | * and allocate resources for a new crypto PMD device instance. | |
404 | * | |
405 | * @param name crypto device name. | |
406 | * @param device base device instance | |
407 | * @param params PMD initialisation parameters | |
408 | * | |
409 | * @return | |
410 | * - crypto device instance on success | |
411 | * - NULL on creation failure | |
412 | */ | |
413 | struct rte_cryptodev * | |
414 | rte_cryptodev_pmd_create(const char *name, | |
415 | struct rte_device *device, | |
416 | struct rte_cryptodev_pmd_init_params *params); | |
417 | ||
418 | /** | |
419 | * @internal | |
420 | * | |
421 | * PMD assist function to provide boiler plate code for crypto driver to | |
422 | * destroy and free resources associated with a crypto PMD device instance. | |
423 | * | |
424 | * @param cryptodev crypto device handle. | |
425 | * | |
426 | * @return | |
427 | * - 0 on success | |
428 | * - errno on failure | |
429 | */ | |
430 | int | |
431 | rte_cryptodev_pmd_destroy(struct rte_cryptodev *cryptodev); | |
432 | ||
7c673cae FG |
433 | /** |
434 | * Executes all the user application registered callbacks for the specific | |
435 | * device. | |
436 | * * | |
437 | * @param dev Pointer to cryptodev struct | |
438 | * @param event Crypto device interrupt event type. | |
439 | * | |
440 | * @return | |
441 | * void | |
442 | */ | |
443 | void rte_cryptodev_pmd_callback_process(struct rte_cryptodev *dev, | |
444 | enum rte_cryptodev_event_type event); | |
445 | ||
11fdf7f2 TL |
446 | /** |
447 | * @internal | |
448 | * Create unique device name | |
449 | */ | |
450 | int | |
451 | rte_cryptodev_pmd_create_dev_name(char *name, const char *dev_name_prefix); | |
452 | ||
9f95a23c TL |
453 | /** |
454 | * @internal | |
455 | * Allocate Cryptodev driver. | |
456 | * | |
457 | * @param crypto_drv | |
458 | * Pointer to cryptodev_driver. | |
459 | * @param drv | |
460 | * Pointer to rte_driver. | |
461 | * | |
462 | * @return | |
463 | * The driver type identifier | |
464 | */ | |
465 | uint8_t rte_cryptodev_allocate_driver(struct cryptodev_driver *crypto_drv, | |
466 | const struct rte_driver *drv); | |
467 | ||
468 | ||
469 | #define RTE_PMD_REGISTER_CRYPTO_DRIVER(crypto_drv, drv, driver_id)\ | |
470 | RTE_INIT(init_ ##driver_id)\ | |
471 | {\ | |
472 | driver_id = rte_cryptodev_allocate_driver(&crypto_drv, &(drv));\ | |
473 | } | |
474 | ||
475 | static inline void * | |
476 | get_sym_session_private_data(const struct rte_cryptodev_sym_session *sess, | |
477 | uint8_t driver_id) { | |
478 | if (unlikely(sess->nb_drivers <= driver_id)) | |
479 | return NULL; | |
480 | ||
481 | return sess->sess_data[driver_id].data; | |
482 | } | |
483 | ||
484 | static inline void | |
485 | set_sym_session_private_data(struct rte_cryptodev_sym_session *sess, | |
486 | uint8_t driver_id, void *private_data) | |
487 | { | |
488 | if (unlikely(sess->nb_drivers <= driver_id)) { | |
489 | CDEV_LOG_ERR("Set private data for driver %u not allowed\n", | |
490 | driver_id); | |
491 | return; | |
492 | } | |
493 | ||
494 | sess->sess_data[driver_id].data = private_data; | |
495 | } | |
496 | ||
497 | static inline void * | |
498 | get_asym_session_private_data(const struct rte_cryptodev_asym_session *sess, | |
499 | uint8_t driver_id) { | |
500 | return sess->sess_private_data[driver_id]; | |
501 | } | |
502 | ||
503 | static inline void | |
504 | set_asym_session_private_data(struct rte_cryptodev_asym_session *sess, | |
505 | uint8_t driver_id, void *private_data) | |
506 | { | |
507 | sess->sess_private_data[driver_id] = private_data; | |
508 | } | |
509 | ||
7c673cae FG |
510 | #ifdef __cplusplus |
511 | } | |
512 | #endif | |
513 | ||
514 | #endif /* _RTE_CRYPTODEV_PMD_H_ */ |