]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /*- |
2 | * | |
3 | * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions | |
7 | * are met: | |
8 | * | |
9 | * * Redistributions of source code must retain the above copyright | |
10 | * notice, this list of conditions and the following disclaimer. | |
11 | * * Redistributions in binary form must reproduce the above copyright | |
12 | * notice, this list of conditions and the following disclaimer in | |
13 | * the documentation and/or other materials provided with the | |
14 | * distribution. | |
15 | * * Neither the name of Intel Corporation nor the names of its | |
16 | * contributors may be used to endorse or promote products derived | |
17 | * from this software without specific prior written permission. | |
18 | * | |
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
20 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
21 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
22 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
23 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
24 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
25 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
26 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
27 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
28 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
29 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
30 | */ | |
31 | ||
32 | #ifndef _RTE_CRYPTODEV_PMD_H_ | |
33 | #define _RTE_CRYPTODEV_PMD_H_ | |
34 | ||
35 | /** @file | |
36 | * RTE Crypto PMD APIs | |
37 | * | |
38 | * @note | |
39 | * These API are from crypto PMD only and user applications should not call | |
40 | * them directly. | |
41 | */ | |
42 | ||
43 | #ifdef __cplusplus | |
44 | extern "C" { | |
45 | #endif | |
46 | ||
47 | #include <string.h> | |
48 | ||
49 | #include <rte_dev.h> | |
50 | #include <rte_pci.h> | |
51 | #include <rte_malloc.h> | |
52 | #include <rte_mbuf.h> | |
53 | #include <rte_mempool.h> | |
54 | #include <rte_log.h> | |
55 | #include <rte_common.h> | |
56 | ||
57 | #include "rte_crypto.h" | |
58 | #include "rte_cryptodev.h" | |
59 | ||
60 | ||
61 | #ifdef RTE_LIBRTE_CRYPTODEV_DEBUG | |
62 | #define RTE_PMD_DEBUG_TRACE(...) \ | |
63 | rte_pmd_debug_trace(__func__, __VA_ARGS__) | |
64 | #else | |
65 | #define RTE_PMD_DEBUG_TRACE(...) | |
66 | #endif | |
67 | ||
68 | struct rte_cryptodev_session { | |
69 | RTE_STD_C11 | |
70 | struct { | |
71 | uint8_t dev_id; | |
72 | enum rte_cryptodev_type type; | |
73 | struct rte_mempool *mp; | |
74 | } __rte_aligned(8); | |
75 | ||
76 | __extension__ char _private[0]; | |
77 | }; | |
78 | ||
79 | struct rte_cryptodev_driver; | |
80 | ||
81 | /** | |
82 | * Initialisation function of a crypto driver invoked for each matching | |
83 | * crypto PCI device detected during the PCI probing phase. | |
84 | * | |
85 | * @param drv The pointer to the [matching] crypto driver structure | |
86 | * supplied by the PMD when it registered itself. | |
87 | * @param dev The dev pointer is the address of the *rte_cryptodev* | |
88 | * structure associated with the matching device and which | |
89 | * has been [automatically] allocated in the | |
90 | * *rte_crypto_devices* array. | |
91 | * | |
92 | * @return | |
93 | * - 0: Success, the device is properly initialised by the driver. | |
94 | * In particular, the driver MUST have set up the *dev_ops* pointer | |
95 | * of the *dev* structure. | |
96 | * - <0: Error code of the device initialisation failure. | |
97 | */ | |
98 | typedef int (*cryptodev_init_t)(struct rte_cryptodev_driver *drv, | |
99 | struct rte_cryptodev *dev); | |
100 | ||
101 | /** | |
102 | * Finalisation function of a driver invoked for each matching | |
103 | * PCI device detected during the PCI closing phase. | |
104 | * | |
105 | * @param drv The pointer to the [matching] driver structure supplied | |
106 | * by the PMD when it registered itself. | |
107 | * @param dev The dev pointer is the address of the *rte_cryptodev* | |
108 | * structure associated with the matching device and which | |
109 | * has been [automatically] allocated in the | |
110 | * *rte_crypto_devices* array. | |
111 | * | |
112 | * * @return | |
113 | * - 0: Success, the device is properly finalised by the driver. | |
114 | * In particular, the driver MUST free the *dev_ops* pointer | |
115 | * of the *dev* structure. | |
116 | * - <0: Error code of the device initialisation failure. | |
117 | */ | |
118 | typedef int (*cryptodev_uninit_t)(const struct rte_cryptodev_driver *drv, | |
119 | struct rte_cryptodev *dev); | |
120 | ||
121 | /** | |
122 | * The structure associated with a PMD driver. | |
123 | * | |
124 | * Each driver acts as a PCI driver and is represented by a generic | |
125 | * *crypto_driver* structure that holds: | |
126 | * | |
127 | * - An *rte_pci_driver* structure (which must be the first field). | |
128 | * | |
129 | * - The *cryptodev_init* function invoked for each matching PCI device. | |
130 | * | |
131 | * - The size of the private data to allocate for each matching device. | |
132 | */ | |
133 | struct rte_cryptodev_driver { | |
134 | struct rte_pci_driver pci_drv; /**< The PMD is also a PCI driver. */ | |
135 | unsigned dev_private_size; /**< Size of device private data. */ | |
136 | ||
137 | cryptodev_init_t cryptodev_init; /**< Device init function. */ | |
138 | cryptodev_uninit_t cryptodev_uninit; /**< Device uninit function. */ | |
139 | }; | |
140 | ||
141 | ||
142 | /** Global structure used for maintaining state of allocated crypto devices */ | |
143 | struct rte_cryptodev_global { | |
144 | struct rte_cryptodev *devs; /**< Device information array */ | |
145 | struct rte_cryptodev_data *data[RTE_CRYPTO_MAX_DEVS]; | |
146 | /**< Device private data */ | |
147 | uint8_t nb_devs; /**< Number of devices found */ | |
148 | uint8_t max_devs; /**< Max number of devices */ | |
149 | }; | |
150 | ||
151 | /** pointer to global crypto devices data structure. */ | |
152 | extern struct rte_cryptodev_global *rte_cryptodev_globals; | |
153 | ||
154 | /** | |
155 | * Get the rte_cryptodev structure device pointer for the device. Assumes a | |
156 | * valid device index. | |
157 | * | |
158 | * @param dev_id Device ID value to select the device structure. | |
159 | * | |
160 | * @return | |
161 | * - The rte_cryptodev structure pointer for the given device ID. | |
162 | */ | |
163 | static inline struct rte_cryptodev * | |
164 | rte_cryptodev_pmd_get_dev(uint8_t dev_id) | |
165 | { | |
166 | return &rte_cryptodev_globals->devs[dev_id]; | |
167 | } | |
168 | ||
169 | /** | |
170 | * Get the rte_cryptodev structure device pointer for the named device. | |
171 | * | |
172 | * @param name device name to select the device structure. | |
173 | * | |
174 | * @return | |
175 | * - The rte_cryptodev structure pointer for the given device ID. | |
176 | */ | |
177 | static inline struct rte_cryptodev * | |
178 | rte_cryptodev_pmd_get_named_dev(const char *name) | |
179 | { | |
180 | struct rte_cryptodev *dev; | |
181 | unsigned i; | |
182 | ||
183 | if (name == NULL) | |
184 | return NULL; | |
185 | ||
186 | for (i = 0, dev = &rte_cryptodev_globals->devs[i]; | |
187 | i < rte_cryptodev_globals->max_devs; i++) { | |
188 | if ((dev->attached == RTE_CRYPTODEV_ATTACHED) && | |
189 | (strcmp(dev->data->name, name) == 0)) | |
190 | return dev; | |
191 | } | |
192 | ||
193 | return NULL; | |
194 | } | |
195 | ||
196 | /** | |
197 | * Validate if the crypto device index is valid attached crypto device. | |
198 | * | |
199 | * @param dev_id Crypto device index. | |
200 | * | |
201 | * @return | |
202 | * - If the device index is valid (1) or not (0). | |
203 | */ | |
204 | static inline unsigned | |
205 | rte_cryptodev_pmd_is_valid_dev(uint8_t dev_id) | |
206 | { | |
207 | struct rte_cryptodev *dev = NULL; | |
208 | ||
209 | if (dev_id >= rte_cryptodev_globals->nb_devs) | |
210 | return 0; | |
211 | ||
212 | dev = rte_cryptodev_pmd_get_dev(dev_id); | |
213 | if (dev->attached != RTE_CRYPTODEV_ATTACHED) | |
214 | return 0; | |
215 | else | |
216 | return 1; | |
217 | } | |
218 | ||
219 | /** | |
220 | * The pool of rte_cryptodev structures. | |
221 | */ | |
222 | extern struct rte_cryptodev *rte_cryptodevs; | |
223 | ||
224 | ||
225 | /** | |
226 | * Definitions of all functions exported by a driver through the | |
227 | * the generic structure of type *crypto_dev_ops* supplied in the | |
228 | * *rte_cryptodev* structure associated with a device. | |
229 | */ | |
230 | ||
231 | /** | |
232 | * Function used to configure device. | |
233 | * | |
234 | * @param dev Crypto device pointer | |
235 | * | |
236 | * @return Returns 0 on success | |
237 | */ | |
238 | typedef int (*cryptodev_configure_t)(struct rte_cryptodev *dev); | |
239 | ||
240 | /** | |
241 | * Function used to start a configured device. | |
242 | * | |
243 | * @param dev Crypto device pointer | |
244 | * | |
245 | * @return Returns 0 on success | |
246 | */ | |
247 | typedef int (*cryptodev_start_t)(struct rte_cryptodev *dev); | |
248 | ||
249 | /** | |
250 | * Function used to stop a configured device. | |
251 | * | |
252 | * @param dev Crypto device pointer | |
253 | */ | |
254 | typedef void (*cryptodev_stop_t)(struct rte_cryptodev *dev); | |
255 | ||
256 | /** | |
257 | * Function used to close a configured device. | |
258 | * | |
259 | * @param dev Crypto device pointer | |
260 | * @return | |
261 | * - 0 on success. | |
262 | * - EAGAIN if can't close as device is busy | |
263 | */ | |
264 | typedef int (*cryptodev_close_t)(struct rte_cryptodev *dev); | |
265 | ||
266 | ||
267 | /** | |
268 | * Function used to get statistics of a device. | |
269 | * | |
270 | * @param dev Crypto device pointer | |
271 | * @param stats Pointer to crypto device stats structure to populate | |
272 | */ | |
273 | typedef void (*cryptodev_stats_get_t)(struct rte_cryptodev *dev, | |
274 | struct rte_cryptodev_stats *stats); | |
275 | ||
276 | ||
277 | /** | |
278 | * Function used to reset statistics of a device. | |
279 | * | |
280 | * @param dev Crypto device pointer | |
281 | */ | |
282 | typedef void (*cryptodev_stats_reset_t)(struct rte_cryptodev *dev); | |
283 | ||
284 | ||
285 | /** | |
286 | * Function used to get specific information of a device. | |
287 | * | |
288 | * @param dev Crypto device pointer | |
289 | */ | |
290 | typedef void (*cryptodev_info_get_t)(struct rte_cryptodev *dev, | |
291 | struct rte_cryptodev_info *dev_info); | |
292 | ||
293 | /** | |
294 | * Start queue pair of a device. | |
295 | * | |
296 | * @param dev Crypto device pointer | |
297 | * @param qp_id Queue Pair Index | |
298 | * | |
299 | * @return Returns 0 on success. | |
300 | */ | |
301 | typedef int (*cryptodev_queue_pair_start_t)(struct rte_cryptodev *dev, | |
302 | uint16_t qp_id); | |
303 | ||
304 | /** | |
305 | * Stop queue pair of a device. | |
306 | * | |
307 | * @param dev Crypto device pointer | |
308 | * @param qp_id Queue Pair Index | |
309 | * | |
310 | * @return Returns 0 on success. | |
311 | */ | |
312 | typedef int (*cryptodev_queue_pair_stop_t)(struct rte_cryptodev *dev, | |
313 | uint16_t qp_id); | |
314 | ||
315 | /** | |
316 | * Setup a queue pair for a device. | |
317 | * | |
318 | * @param dev Crypto device pointer | |
319 | * @param qp_id Queue Pair Index | |
320 | * @param qp_conf Queue configuration structure | |
321 | * @param socket_id Socket Index | |
322 | * | |
323 | * @return Returns 0 on success. | |
324 | */ | |
325 | typedef int (*cryptodev_queue_pair_setup_t)(struct rte_cryptodev *dev, | |
326 | uint16_t qp_id, const struct rte_cryptodev_qp_conf *qp_conf, | |
327 | int socket_id); | |
328 | ||
329 | /** | |
330 | * Release memory resources allocated by given queue pair. | |
331 | * | |
332 | * @param dev Crypto device pointer | |
333 | * @param qp_id Queue Pair Index | |
334 | * | |
335 | * @return | |
336 | * - 0 on success. | |
337 | * - EAGAIN if can't close as device is busy | |
338 | */ | |
339 | typedef int (*cryptodev_queue_pair_release_t)(struct rte_cryptodev *dev, | |
340 | uint16_t qp_id); | |
341 | ||
342 | /** | |
343 | * Get number of available queue pairs of a device. | |
344 | * | |
345 | * @param dev Crypto device pointer | |
346 | * | |
347 | * @return Returns number of queue pairs on success. | |
348 | */ | |
349 | typedef uint32_t (*cryptodev_queue_pair_count_t)(struct rte_cryptodev *dev); | |
350 | ||
351 | /** | |
352 | * Create a session mempool to allocate sessions from | |
353 | * | |
354 | * @param dev Crypto device pointer | |
355 | * @param nb_objs number of sessions objects in mempool | |
356 | * @param obj_cache l-core object cache size, see *rte_ring_create* | |
357 | * @param socket_id Socket Id to allocate mempool on. | |
358 | * | |
359 | * @return | |
360 | * - On success returns a pointer to a rte_mempool | |
361 | * - On failure returns a NULL pointer | |
362 | */ | |
363 | typedef int (*cryptodev_sym_create_session_pool_t)( | |
364 | struct rte_cryptodev *dev, unsigned nb_objs, | |
365 | unsigned obj_cache_size, int socket_id); | |
366 | ||
367 | ||
368 | /** | |
369 | * Get the size of a cryptodev session | |
370 | * | |
371 | * @param dev Crypto device pointer | |
372 | * | |
373 | * @return | |
374 | * - On success returns the size of the session structure for device | |
375 | * - On failure returns 0 | |
376 | */ | |
377 | typedef unsigned (*cryptodev_sym_get_session_private_size_t)( | |
378 | struct rte_cryptodev *dev); | |
379 | ||
380 | /** | |
381 | * Initialize a Crypto session on a device. | |
382 | * | |
383 | * @param dev Crypto device pointer | |
384 | * @param xform Single or chain of crypto xforms | |
385 | * @param priv_sess Pointer to cryptodev's private session structure | |
386 | * | |
387 | * @return | |
388 | * - Returns private session structure on success. | |
389 | * - Returns NULL on failure. | |
390 | */ | |
391 | typedef void (*cryptodev_sym_initialize_session_t)(struct rte_mempool *mempool, | |
392 | void *session_private); | |
393 | ||
394 | /** | |
395 | * Configure a Crypto session on a device. | |
396 | * | |
397 | * @param dev Crypto device pointer | |
398 | * @param xform Single or chain of crypto xforms | |
399 | * @param priv_sess Pointer to cryptodev's private session structure | |
400 | * | |
401 | * @return | |
402 | * - Returns private session structure on success. | |
403 | * - Returns NULL on failure. | |
404 | */ | |
405 | typedef void * (*cryptodev_sym_configure_session_t)(struct rte_cryptodev *dev, | |
406 | struct rte_crypto_sym_xform *xform, void *session_private); | |
407 | ||
408 | /** | |
409 | * Free Crypto session. | |
410 | * @param session Cryptodev session structure to free | |
411 | */ | |
412 | typedef void (*cryptodev_sym_free_session_t)(struct rte_cryptodev *dev, | |
413 | void *session_private); | |
414 | ||
415 | ||
416 | /** Crypto device operations function pointer table */ | |
417 | struct rte_cryptodev_ops { | |
418 | cryptodev_configure_t dev_configure; /**< Configure device. */ | |
419 | cryptodev_start_t dev_start; /**< Start device. */ | |
420 | cryptodev_stop_t dev_stop; /**< Stop device. */ | |
421 | cryptodev_close_t dev_close; /**< Close device. */ | |
422 | ||
423 | cryptodev_info_get_t dev_infos_get; /**< Get device info. */ | |
424 | ||
425 | cryptodev_stats_get_t stats_get; | |
426 | /**< Get device statistics. */ | |
427 | cryptodev_stats_reset_t stats_reset; | |
428 | /**< Reset device statistics. */ | |
429 | ||
430 | cryptodev_queue_pair_setup_t queue_pair_setup; | |
431 | /**< Set up a device queue pair. */ | |
432 | cryptodev_queue_pair_release_t queue_pair_release; | |
433 | /**< Release a queue pair. */ | |
434 | cryptodev_queue_pair_start_t queue_pair_start; | |
435 | /**< Start a queue pair. */ | |
436 | cryptodev_queue_pair_stop_t queue_pair_stop; | |
437 | /**< Stop a queue pair. */ | |
438 | cryptodev_queue_pair_count_t queue_pair_count; | |
439 | /**< Get count of the queue pairs. */ | |
440 | ||
441 | cryptodev_sym_get_session_private_size_t session_get_size; | |
442 | /**< Return private session. */ | |
443 | cryptodev_sym_initialize_session_t session_initialize; | |
444 | /**< Initialization function for private session data */ | |
445 | cryptodev_sym_configure_session_t session_configure; | |
446 | /**< Configure a Crypto session. */ | |
447 | cryptodev_sym_free_session_t session_clear; | |
448 | /**< Clear a Crypto sessions private data. */ | |
449 | }; | |
450 | ||
451 | ||
452 | /** | |
453 | * Function for internal use by dummy drivers primarily, e.g. ring-based | |
454 | * driver. | |
455 | * Allocates a new cryptodev slot for an crypto device and returns the pointer | |
456 | * to that slot for the driver to use. | |
457 | * | |
458 | * @param name Unique identifier name for each device | |
459 | * @param socket_id Socket to allocate resources on. | |
460 | * @return | |
461 | * - Slot in the rte_dev_devices array for a new device; | |
462 | */ | |
463 | struct rte_cryptodev * | |
464 | rte_cryptodev_pmd_allocate(const char *name, int socket_id); | |
465 | ||
466 | /** | |
467 | * Creates a new virtual crypto device and returns the pointer | |
468 | * to that device. | |
469 | * | |
470 | * @param name PMD type name | |
471 | * @param dev_private_size Size of crypto PMDs private data | |
472 | * @param socket_id Socket to allocate resources on. | |
473 | * | |
474 | * @return | |
475 | * - Cryptodev pointer if device is successfully created. | |
476 | * - NULL if device cannot be created. | |
477 | */ | |
478 | struct rte_cryptodev * | |
479 | rte_cryptodev_pmd_virtual_dev_init(const char *name, size_t dev_private_size, | |
480 | int socket_id); | |
481 | ||
482 | ||
483 | /** | |
484 | * Function for internal use by dummy drivers primarily, e.g. ring-based | |
485 | * driver. | |
486 | * Release the specified cryptodev device. | |
487 | * | |
488 | * @param cryptodev | |
489 | * The *cryptodev* pointer is the address of the *rte_cryptodev* structure. | |
490 | * @return | |
491 | * - 0 on success, negative on error | |
492 | */ | |
493 | extern int | |
494 | rte_cryptodev_pmd_release_device(struct rte_cryptodev *cryptodev); | |
495 | ||
496 | /** | |
497 | * Executes all the user application registered callbacks for the specific | |
498 | * device. | |
499 | * * | |
500 | * @param dev Pointer to cryptodev struct | |
501 | * @param event Crypto device interrupt event type. | |
502 | * | |
503 | * @return | |
504 | * void | |
505 | */ | |
506 | void rte_cryptodev_pmd_callback_process(struct rte_cryptodev *dev, | |
507 | enum rte_cryptodev_event_type event); | |
508 | ||
509 | /** | |
510 | * Wrapper for use by pci drivers as a .probe function to attach to a crypto | |
511 | * interface. | |
512 | */ | |
513 | int rte_cryptodev_pci_probe(struct rte_pci_driver *pci_drv, | |
514 | struct rte_pci_device *pci_dev); | |
515 | ||
516 | /** | |
517 | * Wrapper for use by pci drivers as a .remove function to detach a crypto | |
518 | * interface. | |
519 | */ | |
520 | int rte_cryptodev_pci_remove(struct rte_pci_device *pci_dev); | |
521 | ||
522 | #ifdef __cplusplus | |
523 | } | |
524 | #endif | |
525 | ||
526 | #endif /* _RTE_CRYPTODEV_PMD_H_ */ |