Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2021 NVIDIA Corporation & Affiliates
3 : : */
4 : :
5 : : #include <rte_malloc.h>
6 : : #include <rte_mempool.h>
7 : : #include <rte_eal_paging.h>
8 : : #include <rte_errno.h>
9 : : #include <rte_log.h>
10 : : #include <bus_pci_driver.h>
11 : : #include <rte_memory.h>
12 : :
13 : : #include <mlx5_glue.h>
14 : : #include <mlx5_common.h>
15 : : #include <mlx5_devx_cmds.h>
16 : : #include <mlx5_common_os.h>
17 : :
18 : : #include "mlx5_crypto_utils.h"
19 : : #include "mlx5_crypto.h"
20 : :
21 : : #define MLX5_CRYPTO_DRIVER_NAME crypto_mlx5
22 : : #define MLX5_CRYPTO_MAX_QPS 128
23 : :
24 : : #define MLX5_CRYPTO_FEATURE_FLAGS(wrapped_mode) \
25 : : (RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO | RTE_CRYPTODEV_FF_HW_ACCELERATED | \
26 : : RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT | \
27 : : (wrapped_mode ? RTE_CRYPTODEV_FF_CIPHER_WRAPPED_KEY : 0) | \
28 : : RTE_CRYPTODEV_FF_CIPHER_MULTIPLE_DATA_UNITS)
29 : :
30 : : TAILQ_HEAD(mlx5_crypto_privs, mlx5_crypto_priv) mlx5_crypto_priv_list =
31 : : TAILQ_HEAD_INITIALIZER(mlx5_crypto_priv_list);
32 : : static pthread_mutex_t priv_list_lock;
33 : :
34 : : int mlx5_crypto_logtype;
35 : :
36 : : uint8_t mlx5_crypto_driver_id;
37 : :
38 : : static const char mlx5_crypto_drv_name[] = RTE_STR(MLX5_CRYPTO_DRIVER_NAME);
39 : :
40 : : static const struct rte_driver mlx5_drv = {
41 : : .name = mlx5_crypto_drv_name,
42 : : .alias = mlx5_crypto_drv_name
43 : : };
44 : :
45 : : static struct cryptodev_driver mlx5_cryptodev_driver;
46 : :
47 : : static void
48 : 0 : mlx5_crypto_dev_infos_get(struct rte_cryptodev *dev,
49 : : struct rte_cryptodev_info *dev_info)
50 : : {
51 : 0 : struct mlx5_crypto_priv *priv = dev->data->dev_private;
52 : :
53 : : RTE_SET_USED(dev);
54 [ # # ]: 0 : if (dev_info != NULL) {
55 : 0 : dev_info->driver_id = mlx5_crypto_driver_id;
56 : 0 : dev_info->feature_flags =
57 [ # # ]: 0 : MLX5_CRYPTO_FEATURE_FLAGS(priv->is_wrapped_mode);
58 [ # # ]: 0 : if (!mlx5_crypto_is_ipsec_opt(priv))
59 : 0 : dev_info->feature_flags |=
60 : : RTE_CRYPTODEV_FF_IN_PLACE_SGL |
61 : : RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT |
62 : : RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT |
63 : : RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT;
64 : :
65 : 0 : dev_info->capabilities = priv->caps;
66 : 0 : dev_info->max_nb_queue_pairs = MLX5_CRYPTO_MAX_QPS;
67 [ # # ]: 0 : if (priv->caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AEAD) {
68 : 0 : dev_info->min_mbuf_headroom_req = MLX5_CRYPTO_GCM_MAX_AAD;
69 : 0 : dev_info->min_mbuf_tailroom_req = MLX5_CRYPTO_GCM_MAX_DIGEST;
70 : : } else {
71 : 0 : dev_info->min_mbuf_headroom_req = 0;
72 : 0 : dev_info->min_mbuf_tailroom_req = 0;
73 : : }
74 : 0 : dev_info->sym.max_nb_sessions = 0;
75 : : /*
76 : : * If 0, the device does not have any limitation in number of
77 : : * sessions that can be used.
78 : : */
79 : : }
80 : 0 : }
81 : :
82 : : void
83 : 0 : mlx5_crypto_indirect_mkeys_release(struct mlx5_crypto_qp *qp,
84 : : uint16_t n)
85 : : {
86 : : uint32_t i;
87 : :
88 [ # # ]: 0 : for (i = 0; i < n; i++)
89 [ # # ]: 0 : if (qp->mkey[i])
90 : 0 : claim_zero(mlx5_devx_cmd_destroy(qp->mkey[i]));
91 : 0 : }
92 : :
93 : : int
94 : 0 : mlx5_crypto_indirect_mkeys_prepare(struct mlx5_crypto_priv *priv,
95 : : struct mlx5_crypto_qp *qp,
96 : : struct mlx5_devx_mkey_attr *attr,
97 : : mlx5_crypto_mkey_update_t update_cb)
98 : : {
99 : : uint32_t i;
100 : 0 : struct mlx5_hca_attr *hca_attr = &priv->cdev->config.hca_attr;
101 : :
102 : : /* If only relaxed order is allowed. */
103 [ # # ]: 0 : if (hca_attr->mkc_order_write_after_write_ro_only)
104 : 0 : mlx5_devx_mkey_attr_set_ordering(attr, hca_attr);
105 [ # # ]: 0 : for (i = 0; i < qp->entries_n; i++) {
106 : 0 : attr->klm_array = update_cb(priv, qp, i);
107 : 0 : qp->mkey[i] = mlx5_devx_cmd_mkey_create(priv->cdev->ctx, attr);
108 [ # # ]: 0 : if (!qp->mkey[i])
109 : 0 : goto error;
110 : : }
111 : : return 0;
112 : : error:
113 : 0 : DRV_LOG(ERR, "Failed to allocate indirect mkey.");
114 : 0 : mlx5_crypto_indirect_mkeys_release(qp, i);
115 : 0 : return -1;
116 : : }
117 : :
118 : : static int
119 : 0 : mlx5_crypto_dev_configure(struct rte_cryptodev *dev,
120 : : struct rte_cryptodev_config *config)
121 : : {
122 : 0 : struct mlx5_crypto_priv *priv = dev->data->dev_private;
123 : :
124 [ # # ]: 0 : if (config == NULL) {
125 : 0 : DRV_LOG(ERR, "Invalid crypto dev configure parameters.");
126 : 0 : return -EINVAL;
127 : : }
128 [ # # ]: 0 : if ((config->ff_disable & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) != 0) {
129 : 0 : DRV_LOG(ERR,
130 : : "Disabled symmetric crypto feature is not supported.");
131 : 0 : return -ENOTSUP;
132 : : }
133 [ # # ]: 0 : if (mlx5_crypto_dek_setup(priv) != 0) {
134 : 0 : DRV_LOG(ERR, "Dek hash list creation has failed.");
135 : 0 : return -ENOMEM;
136 : : }
137 : 0 : priv->dev_config = *config;
138 : 0 : DRV_LOG(DEBUG, "Device %u was configured.", dev->driver_id);
139 : 0 : return 0;
140 : : }
141 : :
142 : : static void
143 : 0 : mlx5_crypto_dev_stop(struct rte_cryptodev *dev)
144 : : {
145 : : RTE_SET_USED(dev);
146 : 0 : }
147 : :
148 : : static int
149 : 0 : mlx5_crypto_dev_start(struct rte_cryptodev *dev)
150 : : {
151 : 0 : struct mlx5_crypto_priv *priv = dev->data->dev_private;
152 : :
153 : 0 : return mlx5_dev_mempool_subscribe(priv->cdev);
154 : : }
155 : :
156 : : static int
157 : 0 : mlx5_crypto_dev_close(struct rte_cryptodev *dev)
158 : : {
159 : 0 : struct mlx5_crypto_priv *priv = dev->data->dev_private;
160 : :
161 : 0 : mlx5_crypto_dek_unset(priv);
162 : 0 : DRV_LOG(DEBUG, "Device %u was closed.", dev->driver_id);
163 : 0 : return 0;
164 : : }
165 : :
166 : : static unsigned int
167 : 0 : mlx5_crypto_sym_session_get_size(struct rte_cryptodev *dev __rte_unused)
168 : : {
169 : 0 : return sizeof(struct mlx5_crypto_session);
170 : : }
171 : :
172 : : static void
173 : 0 : mlx5_crypto_sym_session_clear(struct rte_cryptodev *dev,
174 : : struct rte_cryptodev_sym_session *sess)
175 : : {
176 : 0 : struct mlx5_crypto_priv *priv = dev->data->dev_private;
177 : 0 : struct mlx5_crypto_session *spriv = CRYPTODEV_GET_SYM_SESS_PRIV(sess);
178 : :
179 : : if (unlikely(spriv == NULL)) {
180 : : DRV_LOG(ERR, "Failed to get session %p private data.", spriv);
181 : : return;
182 : : }
183 : 0 : mlx5_crypto_dek_destroy(priv, spriv->dek);
184 : 0 : DRV_LOG(DEBUG, "Session %p was cleared.", spriv);
185 : : }
186 : :
187 : : static void
188 : 0 : mlx5_crypto_stats_get(struct rte_cryptodev *dev,
189 : : struct rte_cryptodev_stats *stats)
190 : : {
191 : : int qp_id;
192 : :
193 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
194 : 0 : struct mlx5_crypto_qp *qp = dev->data->queue_pairs[qp_id];
195 : :
196 : 0 : stats->enqueued_count += qp->stats.enqueued_count;
197 : 0 : stats->dequeued_count += qp->stats.dequeued_count;
198 : 0 : stats->enqueue_err_count += qp->stats.enqueue_err_count;
199 : 0 : stats->dequeue_err_count += qp->stats.dequeue_err_count;
200 : : }
201 : 0 : }
202 : :
203 : : static void
204 : 0 : mlx5_crypto_stats_reset(struct rte_cryptodev *dev)
205 : : {
206 : : int qp_id;
207 : :
208 [ # # ]: 0 : for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
209 : 0 : struct mlx5_crypto_qp *qp = dev->data->queue_pairs[qp_id];
210 : :
211 : 0 : memset(&qp->stats, 0, sizeof(qp->stats));
212 : : }
213 : 0 : }
214 : :
215 : : static struct rte_cryptodev_ops mlx5_crypto_ops = {
216 : : .dev_configure = mlx5_crypto_dev_configure,
217 : : .dev_start = mlx5_crypto_dev_start,
218 : : .dev_stop = mlx5_crypto_dev_stop,
219 : : .dev_close = mlx5_crypto_dev_close,
220 : : .dev_infos_get = mlx5_crypto_dev_infos_get,
221 : : .stats_get = mlx5_crypto_stats_get,
222 : : .stats_reset = mlx5_crypto_stats_reset,
223 : : .sym_session_get_size = mlx5_crypto_sym_session_get_size,
224 : : .sym_session_clear = mlx5_crypto_sym_session_clear,
225 : : .sym_get_raw_dp_ctx_size = NULL,
226 : : .sym_configure_raw_dp_ctx = NULL,
227 : : };
228 : :
229 : : static int
230 : 0 : mlx5_crypto_args_check_handler(const char *key, const char *val, void *opaque)
231 : : {
232 : : struct mlx5_crypto_devarg_params *devarg_prms = opaque;
233 : : struct mlx5_devx_crypto_login_attr *attr = &devarg_prms->login_attr;
234 : : unsigned long tmp;
235 : : FILE *file;
236 : : int ret;
237 : : int i;
238 : :
239 [ # # ]: 0 : if (strcmp(key, "wcs_file") == 0) {
240 : 0 : file = fopen(val, "rb");
241 [ # # ]: 0 : if (file == NULL) {
242 : 0 : rte_errno = ENOTSUP;
243 : 0 : return -rte_errno;
244 : : }
245 [ # # ]: 0 : for (i = 0 ; i < MLX5_CRYPTO_CREDENTIAL_SIZE ; i++) {
246 : 0 : ret = fscanf(file, "%02hhX", &attr->credential[i]);
247 [ # # ]: 0 : if (ret <= 0) {
248 : 0 : fclose(file);
249 : 0 : DRV_LOG(ERR,
250 : : "Failed to read credential from file.");
251 : 0 : rte_errno = EINVAL;
252 : 0 : return -rte_errno;
253 : : }
254 : : }
255 : 0 : fclose(file);
256 : 0 : devarg_prms->login_devarg = true;
257 : 0 : return 0;
258 [ # # ]: 0 : } else if (strcmp(key, "crypto_mode") == 0) {
259 [ # # ]: 0 : if (strcmp(val, "full_capable") == 0) {
260 : 0 : devarg_prms->crypto_mode = MLX5_CRYPTO_FULL_CAPABLE;
261 [ # # ]: 0 : } else if (strcmp(val, "ipsec_opt") == 0) {
262 : 0 : devarg_prms->crypto_mode = MLX5_CRYPTO_IPSEC_OPT;
263 : : } else {
264 : 0 : DRV_LOG(ERR, "Invalid crypto mode: %s", val);
265 : 0 : rte_errno = EINVAL;
266 : 0 : return -rte_errno;
267 : : }
268 : : }
269 : 0 : errno = 0;
270 : 0 : tmp = strtoul(val, NULL, 0);
271 [ # # ]: 0 : if (errno) {
272 : 0 : DRV_LOG(WARNING, "%s: \"%s\" is an invalid integer.", key, val);
273 : 0 : return -errno;
274 : : }
275 [ # # ]: 0 : if (strcmp(key, "max_segs_num") == 0) {
276 [ # # ]: 0 : if (!tmp) {
277 : 0 : DRV_LOG(ERR, "max_segs_num must be greater than 0.");
278 : 0 : rte_errno = EINVAL;
279 : 0 : return -rte_errno;
280 : : }
281 : 0 : devarg_prms->max_segs_num = (uint32_t)tmp;
282 [ # # ]: 0 : } else if (strcmp(key, "import_kek_id") == 0) {
283 : 0 : attr->session_import_kek_ptr = (uint32_t)tmp;
284 [ # # ]: 0 : } else if (strcmp(key, "credential_id") == 0) {
285 : 0 : attr->credential_pointer = (uint32_t)tmp;
286 [ # # ]: 0 : } else if (strcmp(key, "keytag") == 0) {
287 : 0 : devarg_prms->keytag = tmp;
288 [ # # ]: 0 : } else if (strcmp(key, "algo") == 0) {
289 [ # # ]: 0 : if (tmp == 1) {
290 : 0 : devarg_prms->is_aes_gcm = 1;
291 [ # # ]: 0 : } else if (tmp > 1) {
292 : 0 : DRV_LOG(ERR, "Invalid algo.");
293 : 0 : rte_errno = EINVAL;
294 : 0 : return -rte_errno;
295 : : }
296 : : }
297 : : return 0;
298 : : }
299 : :
300 : : static int
301 : 0 : mlx5_crypto_parse_devargs(struct mlx5_kvargs_ctrl *mkvlist,
302 : : struct mlx5_crypto_devarg_params *devarg_prms,
303 : : bool wrapped_mode)
304 : : {
305 : : struct mlx5_devx_crypto_login_attr *attr = &devarg_prms->login_attr;
306 : 0 : const char **params = (const char *[]){
307 : : "credential_id",
308 : : "import_kek_id",
309 : : "keytag",
310 : : "max_segs_num",
311 : : "wcs_file",
312 : : "algo",
313 : : "crypto_mode",
314 : : NULL,
315 : : };
316 : :
317 : : /* Default values. */
318 : 0 : attr->credential_pointer = 0;
319 : 0 : attr->session_import_kek_ptr = 0;
320 : 0 : devarg_prms->keytag = 0;
321 : 0 : devarg_prms->max_segs_num = 8;
322 [ # # ]: 0 : if (mkvlist == NULL) {
323 [ # # ]: 0 : if (!wrapped_mode)
324 : : return 0;
325 : 0 : DRV_LOG(ERR,
326 : : "No login devargs in order to enable crypto operations in the device.");
327 : 0 : rte_errno = EINVAL;
328 : 0 : return -1;
329 : : }
330 [ # # ]: 0 : if (mlx5_kvargs_process(mkvlist, params, mlx5_crypto_args_check_handler,
331 : : devarg_prms) != 0) {
332 : 0 : DRV_LOG(ERR, "Devargs handler function Failed.");
333 : 0 : rte_errno = EINVAL;
334 : 0 : return -1;
335 : : }
336 [ # # # # ]: 0 : if (devarg_prms->login_devarg == false && wrapped_mode) {
337 : 0 : DRV_LOG(ERR,
338 : : "No login credential devarg in order to enable crypto operations in the device while in wrapped import method.");
339 : 0 : rte_errno = EINVAL;
340 : 0 : return -1;
341 : : }
342 : : return 0;
343 : : }
344 : :
345 : : static int
346 : 0 : mlx5_crypto_dev_probe(struct mlx5_common_device *cdev,
347 : : struct mlx5_kvargs_ctrl *mkvlist)
348 : : {
349 : : struct rte_cryptodev *crypto_dev;
350 : : struct mlx5_devx_obj *login;
351 : : struct mlx5_crypto_priv *priv;
352 : 0 : struct mlx5_crypto_devarg_params devarg_prms = { 0 };
353 : 0 : struct rte_cryptodev_pmd_init_params init_params = {
354 : : .name = "",
355 : : .private_data_size = sizeof(struct mlx5_crypto_priv),
356 : 0 : .socket_id = cdev->dev->numa_node,
357 : : .max_nb_queue_pairs =
358 : : RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
359 : : };
360 [ # # ]: 0 : const char *ibdev_name = mlx5_os_get_ctx_device_name(cdev->ctx);
361 : : int ret;
362 : : bool wrapped_mode;
363 : :
364 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
365 : 0 : DRV_LOG(ERR, "Non-primary process type is not supported.");
366 : 0 : rte_errno = ENOTSUP;
367 : 0 : return -rte_errno;
368 : : }
369 [ # # ]: 0 : if (!cdev->config.hca_attr.crypto ||
370 [ # # ]: 0 : (!cdev->config.hca_attr.aes_xts &&
371 [ # # ]: 0 : !cdev->config.hca_attr.crypto_mmo.crypto_mmo_qp)) {
372 : 0 : DRV_LOG(ERR, "Not enough capabilities to support crypto "
373 : : "operations, maybe old FW/OFED version?");
374 : 0 : rte_errno = ENOTSUP;
375 : 0 : return -ENOTSUP;
376 : : }
377 : 0 : wrapped_mode = !!cdev->config.hca_attr.crypto_wrapped_import_method;
378 : 0 : ret = mlx5_crypto_parse_devargs(mkvlist, &devarg_prms, wrapped_mode);
379 [ # # ]: 0 : if (ret) {
380 : 0 : DRV_LOG(ERR, "Failed to parse devargs.");
381 : 0 : return -rte_errno;
382 : : }
383 : 0 : crypto_dev = rte_cryptodev_pmd_create(ibdev_name, cdev->dev,
384 : : &init_params);
385 [ # # ]: 0 : if (crypto_dev == NULL) {
386 : 0 : DRV_LOG(ERR, "Failed to create device \"%s\".", ibdev_name);
387 : 0 : return -ENODEV;
388 : : }
389 : 0 : DRV_LOG(INFO,
390 : : "Crypto device %s was created successfully.", ibdev_name);
391 : 0 : crypto_dev->dev_ops = &mlx5_crypto_ops;
392 [ # # ]: 0 : crypto_dev->feature_flags = MLX5_CRYPTO_FEATURE_FLAGS(wrapped_mode);
393 : 0 : crypto_dev->driver_id = mlx5_crypto_driver_id;
394 : 0 : priv = crypto_dev->data->dev_private;
395 : 0 : priv->cdev = cdev;
396 : 0 : priv->crypto_dev = crypto_dev;
397 : 0 : priv->is_wrapped_mode = wrapped_mode;
398 : 0 : priv->max_segs_num = devarg_prms.max_segs_num;
399 : 0 : priv->crypto_mode = devarg_prms.crypto_mode;
400 : : /* Init and override AES-GCM configuration. */
401 [ # # ]: 0 : if (devarg_prms.is_aes_gcm) {
402 : 0 : ret = mlx5_crypto_gcm_init(priv);
403 [ # # ]: 0 : if (ret) {
404 : 0 : rte_cryptodev_pmd_destroy(priv->crypto_dev);
405 : 0 : DRV_LOG(ERR, "Failed to init AES-GCM crypto.");
406 : 0 : return -ENOTSUP;
407 : : }
408 : : } else {
409 : 0 : ret = mlx5_crypto_xts_init(priv);
410 [ # # ]: 0 : if (ret) {
411 : 0 : rte_cryptodev_pmd_destroy(priv->crypto_dev);
412 : 0 : DRV_LOG(ERR, "Failed to init AES-XTS crypto.");
413 : 0 : return -ENOTSUP;
414 : : }
415 : : }
416 [ # # ]: 0 : if (mlx5_devx_uar_prepare(cdev, &priv->uar) != 0) {
417 : 0 : rte_cryptodev_pmd_destroy(priv->crypto_dev);
418 : 0 : return -1;
419 : : }
420 [ # # ]: 0 : if (wrapped_mode) {
421 : 0 : login = mlx5_devx_cmd_create_crypto_login_obj(cdev->ctx,
422 : : &devarg_prms.login_attr);
423 [ # # ]: 0 : if (login == NULL) {
424 : 0 : DRV_LOG(ERR, "Failed to configure login.");
425 : 0 : mlx5_devx_uar_release(&priv->uar);
426 : 0 : rte_cryptodev_pmd_destroy(priv->crypto_dev);
427 : 0 : return -rte_errno;
428 : : }
429 : 0 : priv->login_obj = login;
430 : : }
431 [ # # ]: 0 : priv->keytag = rte_cpu_to_be_64(devarg_prms.keytag);
432 : 0 : DRV_LOG(INFO, "Max number of segments: %u.",
433 : : (unsigned int)RTE_MIN(
434 : : MLX5_CRYPTO_KLM_SEGS_NUM(priv->umr_wqe_size),
435 : : (uint16_t)(priv->max_rdmar_ds - 2)));
436 : 0 : pthread_mutex_lock(&priv_list_lock);
437 : 0 : TAILQ_INSERT_TAIL(&mlx5_crypto_priv_list, priv, next);
438 : 0 : pthread_mutex_unlock(&priv_list_lock);
439 : :
440 : 0 : rte_cryptodev_pmd_probing_finish(crypto_dev);
441 : :
442 : 0 : return 0;
443 : : }
444 : :
445 : : static int
446 : 0 : mlx5_crypto_dev_remove(struct mlx5_common_device *cdev)
447 : : {
448 : : struct mlx5_crypto_priv *priv = NULL;
449 : :
450 : 0 : pthread_mutex_lock(&priv_list_lock);
451 [ # # ]: 0 : TAILQ_FOREACH(priv, &mlx5_crypto_priv_list, next)
452 [ # # ]: 0 : if (priv->crypto_dev->device == cdev->dev)
453 : : break;
454 [ # # ]: 0 : if (priv)
455 [ # # ]: 0 : TAILQ_REMOVE(&mlx5_crypto_priv_list, priv, next);
456 : 0 : pthread_mutex_unlock(&priv_list_lock);
457 [ # # ]: 0 : if (priv) {
458 : 0 : claim_zero(mlx5_devx_cmd_destroy(priv->login_obj));
459 : 0 : mlx5_devx_uar_release(&priv->uar);
460 : 0 : rte_cryptodev_pmd_destroy(priv->crypto_dev);
461 : : }
462 : 0 : return 0;
463 : : }
464 : :
465 : : static const struct rte_pci_id mlx5_crypto_pci_id_map[] = {
466 : : {
467 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
468 : : PCI_DEVICE_ID_MELLANOX_CONNECTX6)
469 : : },
470 : : {
471 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
472 : : PCI_DEVICE_ID_MELLANOX_CONNECTX6DX)
473 : : },
474 : : {
475 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
476 : : PCI_DEVICE_ID_MELLANOX_BLUEFIELD2)
477 : : },
478 : : {
479 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
480 : : PCI_DEVICE_ID_MELLANOX_CONNECTX7)
481 : : },
482 : : {
483 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
484 : : PCI_DEVICE_ID_MELLANOX_BLUEFIELD3)
485 : : },
486 : : {
487 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
488 : : PCI_DEVICE_ID_MELLANOX_CONNECTXVF)
489 : : },
490 : : {
491 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
492 : : PCI_DEVICE_ID_MELLANOX_CONNECTX8)
493 : : },
494 : : {
495 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
496 : : PCI_DEVICE_ID_MELLANOX_CONNECTX9)
497 : : },
498 : : {
499 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
500 : : PCI_DEVICE_ID_MELLANOX_BLUEFIELD4)
501 : : },
502 : : {
503 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
504 : : PCI_DEVICE_ID_MELLANOX_CONNECTX10)
505 : : },
506 : : {
507 : : RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
508 : : PCI_DEVICE_ID_MELLANOX_CONNECTX10C2C)
509 : : },
510 : : {
511 : : .vendor_id = 0
512 : : }
513 : : };
514 : :
515 : : static struct mlx5_class_driver mlx5_crypto_driver = {
516 : : .drv_class = MLX5_CLASS_CRYPTO,
517 : : .name = RTE_STR(MLX5_CRYPTO_DRIVER_NAME),
518 : : .id_table = mlx5_crypto_pci_id_map,
519 : : .probe = mlx5_crypto_dev_probe,
520 : : .remove = mlx5_crypto_dev_remove,
521 : : };
522 : :
523 : 303 : RTE_INIT(rte_mlx5_crypto_init)
524 : : {
525 : 303 : pthread_mutex_init(&priv_list_lock, NULL);
526 : 303 : mlx5_common_init();
527 [ + - ]: 303 : if (mlx5_glue != NULL)
528 : 303 : mlx5_class_driver_register(&mlx5_crypto_driver);
529 : 303 : }
530 : :
531 : 303 : RTE_PMD_REGISTER_CRYPTO_DRIVER(mlx5_cryptodev_driver, mlx5_drv,
532 : : mlx5_crypto_driver_id);
533 : :
534 [ - + ]: 303 : RTE_LOG_REGISTER_DEFAULT(mlx5_crypto_logtype, NOTICE)
535 : : RTE_PMD_EXPORT_NAME(MLX5_CRYPTO_DRIVER_NAME);
536 : : RTE_PMD_REGISTER_PCI_TABLE(MLX5_CRYPTO_DRIVER_NAME, mlx5_crypto_pci_id_map);
537 : : RTE_PMD_REGISTER_KMOD_DEP(MLX5_CRYPTO_DRIVER_NAME, "* ib_uverbs & mlx5_core & mlx5_ib");
|
