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