1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2025 Intel Corporation */
3
4 /**
5 ***************************************************************************
6 * @file sal_crypto.c Instance handling functions for crypto
7 *
8 * @ingroup SalCtrl
9 *
10 ***************************************************************************/
11
12 /*
13 *******************************************************************************
14 * Include public/global header files
15 *******************************************************************************
16 */
17
18 /* QAT-API includes */
19 #include "cpa.h"
20 #include "cpa_types.h"
21 #include "cpa_cy_common.h"
22 #include "cpa_cy_im.h"
23 #include "cpa_cy_key.h"
24 #include "cpa_cy_sym.h"
25
26 #include "qat_utils.h"
27
28 /* ADF includes */
29 #include "icp_adf_init.h"
30 #include "icp_adf_transport.h"
31 #include "icp_accel_devices.h"
32 #include "icp_adf_cfg.h"
33 #include "icp_adf_accel_mgr.h"
34 #include "icp_adf_poll.h"
35 #include "icp_adf_debug.h"
36
37 /* SAL includes */
38 #include "lac_log.h"
39 #include "lac_mem.h"
40 #include "lac_mem_pools.h"
41 #include "sal_statistics.h"
42 #include "lac_common.h"
43 #include "lac_list.h"
44 #include "lac_hooks.h"
45 #include "lac_sym_qat_hash_defs_lookup.h"
46 #include "lac_sym.h"
47 #include "lac_sym_key.h"
48 #include "lac_sym_hash.h"
49 #include "lac_sym_cb.h"
50 #include "lac_sym_stats.h"
51 #include "lac_sal_types_crypto.h"
52 #include "lac_sal.h"
53 #include "lac_sal_ctrl.h"
54 #include "sal_string_parse.h"
55 #include "sal_service_state.h"
56 #include "icp_sal_poll.h"
57 #include "lac_sync.h"
58 #include "lac_sym_qat.h"
59 #include "icp_sal_versions.h"
60 #include "icp_sal_user.h"
61 #include "sal_hw_gen.h"
62
63 #define HMAC_MODE_1 1
64 #define HMAC_MODE_2 2
65 #define TH_CY_RX_0 0
66 #define TH_CY_RX_1 1
67 #define MAX_CY_RX_RINGS 2
68
69 #define DOUBLE_INCR 2
70
71 #define TH_SINGLE_RX 0
72 #define NUM_CRYPTO_SYM_RX_RINGS 1
73 #define NUM_CRYPTO_ASYM_RX_RINGS 1
74 #define NUM_CRYPTO_NRBG_RX_RINGS 1
75
76 CpaStatus Lac_GetCyInstancesByType(
77 const CpaAccelerationServiceType accelerationServiceType,
78 Cpa16U numInstances,
79 CpaInstanceHandle *pInstances);
80
81 CpaStatus Lac_GetCyNumInstancesByType(
82 const CpaAccelerationServiceType accelerationServiceType,
83 Cpa16U *pNumInstances);
84
85 static CpaInstanceHandle
Lac_CryptoGetFirstHandle(void)86 Lac_CryptoGetFirstHandle(void)
87 {
88 CpaInstanceHandle instHandle;
89 instHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO);
90 if (!instHandle) {
91 instHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM);
92 if (!instHandle) {
93 instHandle =
94 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_ASYM);
95 }
96 }
97 return instHandle;
98 }
99
100 /* Function to release the sym handles. */
101 static CpaStatus
SalCtrl_SymReleaseTransHandle(sal_service_t * service)102 SalCtrl_SymReleaseTransHandle(sal_service_t *service)
103 {
104
105 CpaStatus status = CPA_STATUS_SUCCESS;
106 CpaStatus ret_status = CPA_STATUS_SUCCESS;
107 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
108
109 if (NULL != pCryptoService->trans_handle_sym_tx) {
110 status = icp_adf_transReleaseHandle(
111 pCryptoService->trans_handle_sym_tx);
112 if (CPA_STATUS_SUCCESS != status) {
113 ret_status = status;
114 }
115 }
116 if (NULL != pCryptoService->trans_handle_sym_rx) {
117 status = icp_adf_transReleaseHandle(
118 pCryptoService->trans_handle_sym_rx);
119 if (CPA_STATUS_SUCCESS != status) {
120 ret_status = status;
121 }
122 }
123
124 return ret_status;
125 }
126
127 /*
128 * @ingroup sal_crypto
129 * Frees resources (memory and transhandles) if allocated
130 *
131 * @param[in] pCryptoService Pointer to sym service instance
132 * @retval SUCCESS if transhandles released
133 * successfully.
134 */
135 static CpaStatus
SalCtrl_SymFreeResources(sal_crypto_service_t * pCryptoService)136 SalCtrl_SymFreeResources(sal_crypto_service_t *pCryptoService)
137 {
138
139 CpaStatus status = CPA_STATUS_SUCCESS;
140
141 /* Free memory pools if not NULL */
142 Lac_MemPoolDestroy(pCryptoService->lac_sym_cookie_pool);
143
144 /* Free misc memory if allocated */
145 /* Frees memory allocated for Hmac precomputes */
146 LacSymHash_HmacPrecompShutdown(pCryptoService);
147 /* Free memory allocated for key labels
148 Also clears key stats */
149 LacSymKey_Shutdown(pCryptoService);
150 /* Free hash lookup table if allocated */
151 if (NULL != pCryptoService->pLacHashLookupDefs) {
152 LAC_OS_FREE(pCryptoService->pLacHashLookupDefs);
153 }
154
155 /* Free statistics */
156 LacSym_StatsFree(pCryptoService);
157
158 /* Free transport handles */
159 status = SalCtrl_SymReleaseTransHandle((sal_service_t *)pCryptoService);
160 return status;
161 }
162
163 /**
164 ***********************************************************************
165 * @ingroup SalCtrl
166 * This macro verifies that the status is _SUCCESS
167 * If status is not _SUCCESS then Sym Instance resources are
168 * freed before the function returns the error
169 *
170 * @param[in] status status we are checking
171 *
172 * @return void status is ok (CPA_STATUS_SUCCESS)
173 * @return status The value in the status parameter is an error one
174 *
175 ****************************************************************************/
176 #define LAC_CHECK_STATUS_SYM_INIT(status) \
177 do { \
178 if (CPA_STATUS_SUCCESS != status) { \
179 SalCtrl_SymFreeResources(pCryptoService); \
180 return status; \
181 } \
182 } while (0)
183
184 /* Function that creates the Sym Handles. */
185 static CpaStatus
SalCtrl_SymCreateTransHandle(icp_accel_dev_t * device,sal_service_t * service,Cpa32U numSymRequests,char * section)186 SalCtrl_SymCreateTransHandle(icp_accel_dev_t *device,
187 sal_service_t *service,
188 Cpa32U numSymRequests,
189 char *section)
190 {
191 CpaStatus status = CPA_STATUS_SUCCESS;
192 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
193 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
194 icp_resp_deliv_method rx_resp_type = ICP_RESP_TYPE_IRQ;
195 Cpa32U msgSize = 0;
196
197 if (SAL_RESP_POLL_CFG_FILE == pCryptoService->isPolled) {
198 rx_resp_type = ICP_RESP_TYPE_POLL;
199 }
200
201 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) {
202 section = icpGetProcessName();
203 }
204
205 /* Parse Sym ring details */
206 status =
207 Sal_StringParsing("Cy",
208 pCryptoService->generic_service_info.instance,
209 "RingSymTx",
210 temp_string);
211
212 /* Need to free resources in case not _SUCCESS from here */
213 LAC_CHECK_STATUS_SYM_INIT(status);
214
215 msgSize = LAC_QAT_SYM_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES;
216 status =
217 icp_adf_transCreateHandle(device,
218 ICP_TRANS_TYPE_ETR,
219 section,
220 pCryptoService->acceleratorNum,
221 pCryptoService->bankNumSym,
222 temp_string,
223 lac_getRingType(SAL_RING_TYPE_A_SYM_HI),
224 NULL,
225 ICP_RESP_TYPE_NONE,
226 numSymRequests,
227 msgSize,
228 (icp_comms_trans_handle *)&(
229 pCryptoService->trans_handle_sym_tx));
230 LAC_CHECK_STATUS_SYM_INIT(status);
231
232 status =
233 Sal_StringParsing("Cy",
234 pCryptoService->generic_service_info.instance,
235 "RingSymRx",
236 temp_string);
237 LAC_CHECK_STATUS_SYM_INIT(status);
238
239 msgSize = LAC_QAT_SYM_RESP_SZ_LW * LAC_LONG_WORD_IN_BYTES;
240 status = icp_adf_transCreateHandle(
241 device,
242 ICP_TRANS_TYPE_ETR,
243 section,
244 pCryptoService->acceleratorNum,
245 pCryptoService->bankNumSym,
246 temp_string,
247 lac_getRingType(SAL_RING_TYPE_NONE),
248 (icp_trans_callback)LacSymQat_SymRespHandler,
249 rx_resp_type,
250 numSymRequests,
251 msgSize,
252 (icp_comms_trans_handle *)&(pCryptoService->trans_handle_sym_rx));
253 LAC_CHECK_STATUS_SYM_INIT(status);
254
255 return status;
256 }
257
258 static int
SalCtrl_CryptoDebug(void * private_data,char * data,int size,int offset)259 SalCtrl_CryptoDebug(void *private_data, char *data, int size, int offset)
260 {
261 CpaStatus status = CPA_STATUS_SUCCESS;
262 Cpa32U len = 0;
263 sal_crypto_service_t *pCryptoService =
264 (sal_crypto_service_t *)private_data;
265
266 switch (offset) {
267 case SAL_STATS_SYM: {
268 CpaCySymStats64 symStats = { 0 };
269 if (CPA_TRUE !=
270 pCryptoService->generic_service_info.stats
271 ->bSymStatsEnabled) {
272 break;
273 }
274 status = cpaCySymQueryStats64(pCryptoService, &symStats);
275 if (status != CPA_STATUS_SUCCESS) {
276 LAC_LOG_ERROR("cpaCySymQueryStats64 returned error\n");
277 return 0;
278 }
279
280 /* Engine Info */
281 len += snprintf(
282 data + len,
283 size - len,
284 SEPARATOR BORDER
285 " Statistics for Instance %24s |\n" BORDER
286 " Symmetric Stats " BORDER
287 "\n" SEPARATOR,
288 pCryptoService->debug_file->name);
289
290 /* Session Info */
291 len += snprintf(
292 data + len,
293 size - len,
294 BORDER " Sessions Initialized: %16llu " BORDER
295 "\n" BORDER
296 " Sessions Removed: %16llu " BORDER
297 "\n" BORDER
298 " Session Errors: %16llu " BORDER
299 "\n" SEPARATOR,
300 (long long unsigned int)symStats.numSessionsInitialized,
301 (long long unsigned int)symStats.numSessionsRemoved,
302 (long long unsigned int)symStats.numSessionErrors);
303
304 /* Session info */
305 len += snprintf(
306 data + len,
307 size - len,
308 BORDER " Symmetric Requests: %16llu " BORDER
309 "\n" BORDER
310 " Symmetric Request Errors: %16llu " BORDER
311 "\n" BORDER
312 " Symmetric Completed: %16llu " BORDER
313 "\n" BORDER
314 " Symmetric Completed Errors: %16llu " BORDER
315 "\n" BORDER
316 " Symmetric Verify Failures: %16llu " BORDER
317 "\n",
318 (long long unsigned int)symStats.numSymOpRequests,
319 (long long unsigned int)symStats.numSymOpRequestErrors,
320 (long long unsigned int)symStats.numSymOpCompleted,
321 (long long unsigned int)symStats.numSymOpCompletedErrors,
322 (long long unsigned int)symStats.numSymOpVerifyFailures);
323 break;
324 }
325 default: {
326 len += snprintf(data + len, size - len, SEPARATOR);
327 return 0;
328 }
329 }
330 return ++offset;
331 }
332
333 static CpaStatus
SalCtrl_SymInit(icp_accel_dev_t * device,sal_service_t * service)334 SalCtrl_SymInit(icp_accel_dev_t *device, sal_service_t *service)
335 {
336 CpaStatus status = CPA_STATUS_SUCCESS;
337 Cpa32U qatHmacMode = 0;
338 Cpa32U numSymConcurrentReq = 0;
339 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
340 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
341 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
342 char *section = DYN_SEC;
343
344 /*Instance may not in the DYN section*/
345 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) {
346 section = icpGetProcessName();
347 }
348
349 /* Register callbacks for the symmetric services
350 * (Hash, Cipher, Algorithm-Chaining) (returns void)*/
351 LacSymCb_CallbacksRegister();
352
353 qatHmacMode = (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
354 switch (qatHmacMode) {
355 case HMAC_MODE_1:
356 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE1;
357 break;
358 case HMAC_MODE_2:
359 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE2;
360 break;
361 default:
362 pCryptoService->qatHmacMode = ICP_QAT_HW_AUTH_MODE1;
363 break;
364 }
365
366 /* Get num concurrent requests from config file */
367 status =
368 Sal_StringParsing("Cy",
369 pCryptoService->generic_service_info.instance,
370 "NumConcurrentSymRequests",
371 temp_string);
372 LAC_CHECK_STATUS(status);
373 status =
374 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
375 if (CPA_STATUS_SUCCESS != status) {
376 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
377 temp_string);
378 return status;
379 }
380
381 numSymConcurrentReq =
382 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
383 if (CPA_STATUS_FAIL == validateConcurrRequest(numSymConcurrentReq)) {
384 LAC_LOG_ERROR("Invalid NumConcurrentSymRequests, valid "
385 "values {64, 128, 256, ... 32768, 65536}");
386 return CPA_STATUS_FAIL;
387 }
388
389 /* ADF does not allow us to completely fill the ring for batch requests
390 */
391 pCryptoService->maxNumSymReqBatch =
392 (numSymConcurrentReq - SAL_BATCH_SUBMIT_FREE_SPACE);
393
394 /* Create transport handles */
395 status = SalCtrl_SymCreateTransHandle(device,
396 service,
397 numSymConcurrentReq,
398 section);
399 LAC_CHECK_STATUS(status);
400
401 /* Allocates memory pools */
402
403 /* Create and initialise symmetric cookie memory pool */
404 pCryptoService->lac_sym_cookie_pool = LAC_MEM_POOL_INIT_POOL_ID;
405 status =
406 Sal_StringParsing("Cy",
407 pCryptoService->generic_service_info.instance,
408 "SymPool",
409 temp_string);
410 LAC_CHECK_STATUS_SYM_INIT(status);
411 /* Note we need twice (i.e. <<1) the number of sym cookies to
412 support sym ring pairs (and some, for partials) */
413 status =
414 Lac_MemPoolCreate(&pCryptoService->lac_sym_cookie_pool,
415 temp_string,
416 ((numSymConcurrentReq + numSymConcurrentReq + 1)
417 << 1),
418 sizeof(lac_sym_cookie_t),
419 LAC_64BYTE_ALIGNMENT,
420 CPA_FALSE,
421 pCryptoService->nodeAffinity);
422 LAC_CHECK_STATUS_SYM_INIT(status);
423 /* For all sym cookies fill out the physical address of data that
424 will be set to QAT */
425 Lac_MemPoolInitSymCookiesPhyAddr(pCryptoService->lac_sym_cookie_pool);
426
427 /* Clear stats */
428 /* Clears Key stats and allocate memory of SSL and TLS labels
429 These labels are initialised to standard values */
430 status = LacSymKey_Init(pCryptoService);
431 LAC_CHECK_STATUS_SYM_INIT(status);
432
433 /* Initialises the hash lookup table*/
434 status = LacSymQat_Init(pCryptoService);
435 LAC_CHECK_STATUS_SYM_INIT(status);
436
437 /* Fills out content descriptor for precomputes and registers the
438 hash precompute callback */
439 status = LacSymHash_HmacPrecompInit(pCryptoService);
440 LAC_CHECK_STATUS_SYM_INIT(status);
441
442 /* Init the Sym stats */
443 status = LacSym_StatsInit(pCryptoService);
444 LAC_CHECK_STATUS_SYM_INIT(status);
445
446 return status;
447 }
448
449 static void
SalCtrl_DebugShutdown(icp_accel_dev_t * device,sal_service_t * service)450 SalCtrl_DebugShutdown(icp_accel_dev_t *device, sal_service_t *service)
451 {
452 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
453 sal_statistics_collection_t *pStatsCollection =
454 (sal_statistics_collection_t *)device->pQatStats;
455
456 if (CPA_TRUE == pStatsCollection->bStatsEnabled) {
457 /* Clean stats */
458 if (NULL != pCryptoService->debug_file) {
459 icp_adf_debugRemoveFile(pCryptoService->debug_file);
460 LAC_OS_FREE(pCryptoService->debug_file->name);
461 LAC_OS_FREE(pCryptoService->debug_file);
462 pCryptoService->debug_file = NULL;
463 }
464 }
465 pCryptoService->generic_service_info.stats = NULL;
466 }
467
468 static CpaStatus
SalCtrl_DebugInit(icp_accel_dev_t * device,sal_service_t * service)469 SalCtrl_DebugInit(icp_accel_dev_t *device, sal_service_t *service)
470 {
471 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
472 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
473 char *instance_name = NULL;
474 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
475 sal_statistics_collection_t *pStatsCollection =
476 (sal_statistics_collection_t *)device->pQatStats;
477 CpaStatus status = CPA_STATUS_SUCCESS;
478 char *section = DYN_SEC;
479
480 /*Instance may not in the DYN section*/
481 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) {
482 section = icpGetProcessName();
483 }
484
485 if (CPA_TRUE == pStatsCollection->bStatsEnabled) {
486 /* Get instance name for stats */
487 instance_name = LAC_OS_MALLOC(ADF_CFG_MAX_VAL_LEN_IN_BYTES);
488 if (NULL == instance_name) {
489 return CPA_STATUS_RESOURCE;
490 }
491
492 status = Sal_StringParsing(
493 "Cy",
494 pCryptoService->generic_service_info.instance,
495 "Name",
496 temp_string);
497 if (CPA_STATUS_SUCCESS != status) {
498 LAC_OS_FREE(instance_name);
499 return status;
500 }
501 status = icp_adf_cfgGetParamValue(device,
502 section,
503 temp_string,
504 adfGetParam);
505 if (CPA_STATUS_SUCCESS != status) {
506 QAT_UTILS_LOG(
507 "Failed to get %s from configuration file\n",
508 temp_string);
509 LAC_OS_FREE(instance_name);
510 return status;
511 }
512 snprintf(instance_name,
513 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
514 "%s",
515 adfGetParam);
516
517 pCryptoService->debug_file =
518 LAC_OS_MALLOC(sizeof(debug_file_info_t));
519 if (NULL == pCryptoService->debug_file) {
520 LAC_OS_FREE(instance_name);
521 return CPA_STATUS_RESOURCE;
522 }
523
524 memset(pCryptoService->debug_file,
525 0,
526 sizeof(debug_file_info_t));
527 pCryptoService->debug_file->name = instance_name;
528 pCryptoService->debug_file->seq_read = SalCtrl_CryptoDebug;
529 pCryptoService->debug_file->private_data = pCryptoService;
530 pCryptoService->debug_file->parent =
531 pCryptoService->generic_service_info.debug_parent_dir;
532
533 status =
534 icp_adf_debugAddFile(device, pCryptoService->debug_file);
535 if (CPA_STATUS_SUCCESS != status) {
536 LAC_OS_FREE(instance_name);
537 LAC_OS_FREE(pCryptoService->debug_file);
538 return status;
539 }
540 }
541 pCryptoService->generic_service_info.stats = pStatsCollection;
542
543 return status;
544 }
545
546 static CpaStatus
SalCtrl_GetBankNum(icp_accel_dev_t * device,Cpa32U inst,char * section,char * bank_name,Cpa16U * bank)547 SalCtrl_GetBankNum(icp_accel_dev_t *device,
548 Cpa32U inst,
549 char *section,
550 char *bank_name,
551 Cpa16U *bank)
552 {
553 char adfParamValue[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
554 char adfParamName[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
555 CpaStatus status = CPA_STATUS_SUCCESS;
556
557 status = Sal_StringParsing("Cy", inst, bank_name, adfParamName);
558 LAC_CHECK_STATUS(status);
559 status = icp_adf_cfgGetParamValue(device,
560 section,
561 adfParamName,
562 adfParamValue);
563 if (CPA_STATUS_SUCCESS != status) {
564 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
565 adfParamName);
566 return status;
567 }
568 *bank = (Cpa16U)Sal_Strtoul(adfParamValue, NULL, SAL_CFG_BASE_DEC);
569 return status;
570 }
571
572 static CpaStatus
SalCtr_InstInit(icp_accel_dev_t * device,sal_service_t * service)573 SalCtr_InstInit(icp_accel_dev_t *device, sal_service_t *service)
574 {
575 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
576 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
577 char temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
578 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
579 CpaStatus status = CPA_STATUS_SUCCESS;
580 char *section = DYN_SEC;
581
582 /*Instance may not in the DYN section*/
583 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) {
584 section = icpGetProcessName();
585 }
586
587 /* Get Config Info: Accel Num, bank Num, packageID,
588 coreAffinity, nodeAffinity and response mode */
589
590 pCryptoService->acceleratorNum = 0;
591
592 /* Gen4, a bank only has 2 rings (1 ring pair), only one type of service
593 can be assigned one time. asym and sym will be in different bank*/
594 if (isCyGen4x(pCryptoService)) {
595 switch (service->type) {
596 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
597 status = SalCtrl_GetBankNum(
598 device,
599 pCryptoService->generic_service_info.instance,
600 section,
601 "BankNumberAsym",
602 &pCryptoService->bankNumAsym);
603 if (CPA_STATUS_SUCCESS != status)
604 return status;
605 break;
606 case SAL_SERVICE_TYPE_CRYPTO_SYM:
607 status = SalCtrl_GetBankNum(
608 device,
609 pCryptoService->generic_service_info.instance,
610 section,
611 "BankNumberSym",
612 &pCryptoService->bankNumSym);
613 if (CPA_STATUS_SUCCESS != status)
614 return status;
615 break;
616 case SAL_SERVICE_TYPE_CRYPTO:
617 status = SalCtrl_GetBankNum(
618 device,
619 pCryptoService->generic_service_info.instance,
620 section,
621 "BankNumberAsym",
622 &pCryptoService->bankNumAsym);
623 if (CPA_STATUS_SUCCESS != status)
624 return status;
625 status = SalCtrl_GetBankNum(
626 device,
627 pCryptoService->generic_service_info.instance,
628 section,
629 "BankNumberSym",
630 &pCryptoService->bankNumSym);
631 if (CPA_STATUS_SUCCESS != status)
632 return status;
633 break;
634 default:
635 return CPA_STATUS_FAIL;
636 }
637 } else {
638 status = SalCtrl_GetBankNum(
639 device,
640 pCryptoService->generic_service_info.instance,
641 section,
642 "BankNumber",
643 &pCryptoService->bankNumSym);
644 if (CPA_STATUS_SUCCESS != status)
645 return status;
646 pCryptoService->bankNumAsym = pCryptoService->bankNumSym;
647 }
648
649 status =
650 Sal_StringParsing("Cy",
651 pCryptoService->generic_service_info.instance,
652 "IsPolled",
653 temp_string);
654 LAC_CHECK_STATUS(status);
655 status =
656 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
657 if (CPA_STATUS_SUCCESS != status) {
658 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
659 temp_string);
660 return status;
661 }
662 pCryptoService->isPolled =
663 (Cpa8U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
664
665 /* Kernel instances do not support epoll mode */
666 if (SAL_RESP_EPOLL_CFG_FILE == pCryptoService->isPolled) {
667 QAT_UTILS_LOG(
668 "IsPolled %u is not supported for kernel instance %s",
669 pCryptoService->isPolled,
670 temp_string);
671 return CPA_STATUS_FAIL;
672 }
673
674 status = icp_adf_cfgGetParamValue(device,
675 LAC_CFG_SECTION_GENERAL,
676 ADF_DEV_PKG_ID,
677 adfGetParam);
678 if (CPA_STATUS_SUCCESS != status) {
679 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
680 ADF_DEV_PKG_ID);
681 return status;
682 }
683 pCryptoService->pkgID =
684 (Cpa16U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
685
686 status = icp_adf_cfgGetParamValue(device,
687 LAC_CFG_SECTION_GENERAL,
688 ADF_DEV_NODE_ID,
689 adfGetParam);
690 if (CPA_STATUS_SUCCESS != status) {
691 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
692 ADF_DEV_NODE_ID);
693 return status;
694 }
695 pCryptoService->nodeAffinity =
696 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
697 /* In case of interrupt instance, use the bank affinity set by adf_ctl
698 * Otherwise, use the instance affinity for backwards compatibility */
699 if (SAL_RESP_POLL_CFG_FILE != pCryptoService->isPolled) {
700 /* Next need to read the [AcceleratorX] section of the config
701 * file */
702 status = Sal_StringParsing("Accelerator",
703 pCryptoService->acceleratorNum,
704 "",
705 temp_string2);
706 LAC_CHECK_STATUS(status);
707 if (service->type == SAL_SERVICE_TYPE_CRYPTO_ASYM)
708 status = Sal_StringParsing("Bank",
709 pCryptoService->bankNumAsym,
710 "CoreAffinity",
711 temp_string);
712 else
713 /* For cy service, asym bank and sym bank will set the
714 same core affinity. So Just read one*/
715 status = Sal_StringParsing("Bank",
716 pCryptoService->bankNumSym,
717 "CoreAffinity",
718 temp_string);
719 LAC_CHECK_STATUS(status);
720 } else {
721 strncpy(temp_string2, section, (strlen(section) + 1));
722 status = Sal_StringParsing(
723 "Cy",
724 pCryptoService->generic_service_info.instance,
725 "CoreAffinity",
726 temp_string);
727 LAC_CHECK_STATUS(status);
728 }
729
730 status = icp_adf_cfgGetParamValue(device,
731 temp_string2,
732 temp_string,
733 adfGetParam);
734 if (CPA_STATUS_SUCCESS != status) {
735 QAT_UTILS_LOG("Failed to get %s from configuration file\n",
736 temp_string);
737 return status;
738 }
739 pCryptoService->coreAffinity =
740 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
741
742 /*No Execution Engine in DH895xcc, so make sure it is zero*/
743 pCryptoService->executionEngine = 0;
744
745 return status;
746 }
747
748 /* This function:
749 * 1. Creates sym and asym transport handles
750 * 2. Allocates memory pools required by sym and asym services
751 .* 3. Clears the sym and asym stats counters
752 * 4. In case service asym or sym is enabled then this function
753 * only allocates resources for these services. i.e if the
754 * service asym is enabled then only asym transport handles
755 * are created and vice versa.
756 */
757 CpaStatus
SalCtrl_CryptoInit(icp_accel_dev_t * device,sal_service_t * service)758 SalCtrl_CryptoInit(icp_accel_dev_t *device, sal_service_t *service)
759 {
760 CpaStatus status = CPA_STATUS_SUCCESS;
761 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
762 sal_service_type_t svc_type = service->type;
763
764 SAL_SERVICE_GOOD_FOR_INIT(pCryptoService);
765 pCryptoService->generic_service_info.state =
766 SAL_SERVICE_STATE_INITIALIZING;
767
768 /* Set up the instance parameters such as bank number,
769 * coreAffinity, pkgId and node affinity etc
770 */
771 status = SalCtr_InstInit(device, service);
772 LAC_CHECK_STATUS(status);
773 /* Create debug directory for service */
774 status = SalCtrl_DebugInit(device, service);
775 LAC_CHECK_STATUS(status);
776
777 switch (svc_type) {
778 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
779 break;
780 case SAL_SERVICE_TYPE_CRYPTO_SYM:
781 status = SalCtrl_SymInit(device, service);
782 if (CPA_STATUS_SUCCESS != status) {
783 SalCtrl_DebugShutdown(device, service);
784 return status;
785 }
786 break;
787 case SAL_SERVICE_TYPE_CRYPTO:
788 status = SalCtrl_SymInit(device, service);
789 if (CPA_STATUS_SUCCESS != status) {
790 SalCtrl_DebugShutdown(device, service);
791 return status;
792 }
793 break;
794 default:
795 LAC_LOG_ERROR("Invalid service type\n");
796 status = CPA_STATUS_FAIL;
797 break;
798 }
799
800 pCryptoService->generic_service_info.state =
801 SAL_SERVICE_STATE_INITIALIZED;
802
803 return status;
804 }
805
806 CpaStatus
SalCtrl_CryptoStart(icp_accel_dev_t * device,sal_service_t * service)807 SalCtrl_CryptoStart(icp_accel_dev_t *device, sal_service_t *service)
808 {
809 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
810 CpaStatus status = CPA_STATUS_SUCCESS;
811
812 if (pCryptoService->generic_service_info.state !=
813 SAL_SERVICE_STATE_INITIALIZED) {
814 LAC_LOG_ERROR("Not in the correct state to call start\n");
815 return CPA_STATUS_FAIL;
816 }
817
818 pCryptoService->generic_service_info.state = SAL_SERVICE_STATE_RUNNING;
819 return status;
820 }
821
822 CpaStatus
SalCtrl_CryptoStop(icp_accel_dev_t * device,sal_service_t * service)823 SalCtrl_CryptoStop(icp_accel_dev_t *device, sal_service_t *service)
824 {
825 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
826
827 if (SAL_SERVICE_STATE_RUNNING !=
828 pCryptoService->generic_service_info.state) {
829 LAC_LOG_ERROR("Not in the correct state to call stop");
830 }
831
832 pCryptoService->generic_service_info.state =
833 SAL_SERVICE_STATE_SHUTTING_DOWN;
834 return CPA_STATUS_SUCCESS;
835 }
836
837 CpaStatus
SalCtrl_CryptoShutdown(icp_accel_dev_t * device,sal_service_t * service)838 SalCtrl_CryptoShutdown(icp_accel_dev_t *device, sal_service_t *service)
839 {
840 sal_crypto_service_t *pCryptoService = (sal_crypto_service_t *)service;
841 CpaStatus status = CPA_STATUS_SUCCESS;
842 sal_service_type_t svc_type = service->type;
843
844 if ((SAL_SERVICE_STATE_INITIALIZED !=
845 pCryptoService->generic_service_info.state) &&
846 (SAL_SERVICE_STATE_SHUTTING_DOWN !=
847 pCryptoService->generic_service_info.state)) {
848 LAC_LOG_ERROR("Not in the correct state to call shutdown \n");
849 return CPA_STATUS_FAIL;
850 }
851
852 /* Free memory and transhandles */
853 switch (svc_type) {
854 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
855 break;
856 case SAL_SERVICE_TYPE_CRYPTO_SYM:
857 if (SalCtrl_SymFreeResources(pCryptoService)) {
858 status = CPA_STATUS_FAIL;
859 }
860 break;
861 case SAL_SERVICE_TYPE_CRYPTO:
862 if (SalCtrl_SymFreeResources(pCryptoService)) {
863 status = CPA_STATUS_FAIL;
864 }
865 break;
866 default:
867 LAC_LOG_ERROR("Invalid service type\n");
868 status = CPA_STATUS_FAIL;
869 break;
870 }
871
872 SalCtrl_DebugShutdown(device, service);
873
874 pCryptoService->generic_service_info.state = SAL_SERVICE_STATE_SHUTDOWN;
875
876 return status;
877 }
878
879 /**
880 ******************************************************************************
881 * @ingroup cpaCyCommon
882 *****************************************************************************/
883 CpaStatus
cpaCyGetStatusText(const CpaInstanceHandle instanceHandle,CpaStatus errStatus,Cpa8S * pStatusText)884 cpaCyGetStatusText(const CpaInstanceHandle instanceHandle,
885 CpaStatus errStatus,
886 Cpa8S *pStatusText)
887 {
888 CpaStatus status = CPA_STATUS_SUCCESS;
889
890 LAC_CHECK_NULL_PARAM(pStatusText);
891
892 switch (errStatus) {
893 case CPA_STATUS_SUCCESS:
894 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_SUCCESS);
895 break;
896 case CPA_STATUS_FAIL:
897 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FAIL);
898 break;
899 case CPA_STATUS_RETRY:
900 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RETRY);
901 break;
902 case CPA_STATUS_RESOURCE:
903 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RESOURCE);
904 break;
905 case CPA_STATUS_INVALID_PARAM:
906 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_INVALID_PARAM);
907 break;
908 case CPA_STATUS_FATAL:
909 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FATAL);
910 break;
911 case CPA_STATUS_UNSUPPORTED:
912 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_UNSUPPORTED);
913 break;
914 default:
915 status = CPA_STATUS_INVALID_PARAM;
916 break;
917 }
918 return status;
919 }
920
921 void
SalCtrl_CyQueryCapabilities(sal_service_t * pGenericService,CpaCyCapabilitiesInfo * pCapInfo)922 SalCtrl_CyQueryCapabilities(sal_service_t *pGenericService,
923 CpaCyCapabilitiesInfo *pCapInfo)
924 {
925 memset(pCapInfo, 0, sizeof(CpaCyCapabilitiesInfo));
926
927 if (SAL_SERVICE_TYPE_CRYPTO == pGenericService->type ||
928 SAL_SERVICE_TYPE_CRYPTO_SYM == pGenericService->type) {
929 pCapInfo->symSupported = CPA_TRUE;
930 if (pGenericService->capabilitiesMask &
931 ICP_ACCEL_CAPABILITIES_EXT_ALGCHAIN) {
932 pCapInfo->extAlgchainSupported = CPA_TRUE;
933 }
934
935 if (pGenericService->capabilitiesMask &
936 ICP_ACCEL_CAPABILITIES_HKDF) {
937 pCapInfo->hkdfSupported = CPA_TRUE;
938 }
939 }
940
941 if (pGenericService->capabilitiesMask &
942 ICP_ACCEL_CAPABILITIES_ECEDMONT) {
943 pCapInfo->ecEdMontSupported = CPA_TRUE;
944 }
945
946 if (pGenericService->capabilitiesMask &
947 ICP_ACCEL_CAPABILITIES_RANDOM_NUMBER) {
948 pCapInfo->nrbgSupported = CPA_TRUE;
949 }
950
951 pCapInfo->drbgSupported = CPA_FALSE;
952 pCapInfo->randSupported = CPA_FALSE;
953 pCapInfo->nrbgSupported = CPA_FALSE;
954 }
955
956 /**
957 ******************************************************************************
958 * @ingroup cpaCyCommon
959 *****************************************************************************/
960 CpaStatus
cpaCyStartInstance(CpaInstanceHandle instanceHandle_in)961 cpaCyStartInstance(CpaInstanceHandle instanceHandle_in)
962 {
963 CpaInstanceHandle instanceHandle = NULL;
964 /* Structure initializer is supported by C99, but it is
965 * not supported by some former Intel compilers.
966 */
967 CpaInstanceInfo2 info = { 0 };
968 icp_accel_dev_t *dev = NULL;
969 CpaStatus status = CPA_STATUS_SUCCESS;
970 sal_crypto_service_t *pService = NULL;
971
972 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
973 instanceHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO);
974 if (!instanceHandle) {
975 instanceHandle =
976 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM);
977 }
978 } else {
979 instanceHandle = instanceHandle_in;
980 }
981 LAC_CHECK_NULL_PARAM(instanceHandle);
982 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
983 (SAL_SERVICE_TYPE_CRYPTO |
984 SAL_SERVICE_TYPE_CRYPTO_ASYM |
985 SAL_SERVICE_TYPE_CRYPTO_SYM));
986
987 pService = (sal_crypto_service_t *)instanceHandle;
988
989 status = cpaCyInstanceGetInfo2(instanceHandle, &info);
990 if (CPA_STATUS_SUCCESS != status) {
991 LAC_LOG_ERROR("Can not get instance info\n");
992 return status;
993 }
994 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
995 if (NULL == dev) {
996 LAC_LOG_ERROR("Can not find device for the instance\n");
997 return CPA_STATUS_FAIL;
998 }
999
1000 pService->generic_service_info.isInstanceStarted = CPA_TRUE;
1001
1002 /* Increment dev ref counter */
1003 icp_qa_dev_get(dev);
1004 return CPA_STATUS_SUCCESS;
1005 }
1006
1007 /**
1008 ******************************************************************************
1009 * @ingroup cpaCyCommon
1010 *****************************************************************************/
1011 CpaStatus
cpaCyStopInstance(CpaInstanceHandle instanceHandle_in)1012 cpaCyStopInstance(CpaInstanceHandle instanceHandle_in)
1013 {
1014 CpaInstanceHandle instanceHandle = NULL;
1015 /* Structure initializer is supported by C99, but it is
1016 * not supported by some former Intel compilers.
1017 */
1018 CpaInstanceInfo2 info = { 0 };
1019 icp_accel_dev_t *dev = NULL;
1020 CpaStatus status = CPA_STATUS_SUCCESS;
1021 sal_crypto_service_t *pService = NULL;
1022
1023 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1024 instanceHandle = Lac_CryptoGetFirstHandle();
1025 } else {
1026 instanceHandle = instanceHandle_in;
1027 }
1028 LAC_CHECK_NULL_PARAM(instanceHandle);
1029 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1030 (SAL_SERVICE_TYPE_CRYPTO |
1031 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1032 SAL_SERVICE_TYPE_CRYPTO_SYM));
1033
1034 status = cpaCyInstanceGetInfo2(instanceHandle, &info);
1035 if (CPA_STATUS_SUCCESS != status) {
1036 LAC_LOG_ERROR("Can not get instance info\n");
1037 return status;
1038 }
1039 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
1040 if (NULL == dev) {
1041 LAC_LOG_ERROR("Can not find device for the instance\n");
1042 return CPA_STATUS_FAIL;
1043 }
1044
1045 pService = (sal_crypto_service_t *)instanceHandle;
1046
1047 pService->generic_service_info.isInstanceStarted = CPA_FALSE;
1048
1049 /* Decrement dev ref counter */
1050 icp_qa_dev_put(dev);
1051 return CPA_STATUS_SUCCESS;
1052 }
1053
1054 /**
1055 ******************************************************************************
1056 * @ingroup cpaCyCommon
1057 *****************************************************************************/
1058 CpaStatus
cpaCyInstanceSetNotificationCb(const CpaInstanceHandle instanceHandle,const CpaCyInstanceNotificationCbFunc pInstanceNotificationCb,void * pCallbackTag)1059 cpaCyInstanceSetNotificationCb(
1060 const CpaInstanceHandle instanceHandle,
1061 const CpaCyInstanceNotificationCbFunc pInstanceNotificationCb,
1062 void *pCallbackTag)
1063 {
1064 CpaStatus status = CPA_STATUS_SUCCESS;
1065 sal_service_t *gen_handle = instanceHandle;
1066
1067 LAC_CHECK_NULL_PARAM(gen_handle);
1068 gen_handle->notification_cb = pInstanceNotificationCb;
1069 gen_handle->cb_tag = pCallbackTag;
1070 return status;
1071 }
1072
1073 /**
1074 ******************************************************************************
1075 * @ingroup cpaCyCommon
1076 *****************************************************************************/
1077 CpaStatus
cpaCyGetNumInstances(Cpa16U * pNumInstances)1078 cpaCyGetNumInstances(Cpa16U *pNumInstances)
1079 {
1080 return Lac_GetCyNumInstancesByType(CPA_ACC_SVC_TYPE_CRYPTO,
1081 pNumInstances);
1082 }
1083
1084 /**
1085 ******************************************************************************
1086 * @ingroup cpaCyCommon
1087 *****************************************************************************/
1088 CpaStatus
cpaCyGetInstances(Cpa16U numInstances,CpaInstanceHandle * pCyInstances)1089 cpaCyGetInstances(Cpa16U numInstances, CpaInstanceHandle *pCyInstances)
1090 {
1091 return Lac_GetCyInstancesByType(CPA_ACC_SVC_TYPE_CRYPTO,
1092 numInstances,
1093 pCyInstances);
1094 }
1095
1096 /**
1097 ******************************************************************************
1098 * @ingroup cpaCyCommon
1099 *****************************************************************************/
1100 CpaStatus
cpaCyInstanceGetInfo(const CpaInstanceHandle instanceHandle_in,struct _CpaInstanceInfo * pInstanceInfo)1101 cpaCyInstanceGetInfo(const CpaInstanceHandle instanceHandle_in,
1102 struct _CpaInstanceInfo *pInstanceInfo)
1103 {
1104 CpaInstanceHandle instanceHandle = NULL;
1105 sal_crypto_service_t *pCryptoService = NULL;
1106 sal_service_t *pGenericService = NULL;
1107
1108 Cpa8U name[CPA_INST_NAME_SIZE] =
1109 "Intel(R) DH89XXCC instance number: %02x, type: Crypto";
1110
1111 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1112 instanceHandle = Lac_CryptoGetFirstHandle();
1113 } else {
1114 instanceHandle = instanceHandle_in;
1115 }
1116
1117 LAC_CHECK_NULL_PARAM(instanceHandle);
1118 LAC_CHECK_NULL_PARAM(pInstanceInfo);
1119 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1120 (SAL_SERVICE_TYPE_CRYPTO |
1121 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1122 SAL_SERVICE_TYPE_CRYPTO_SYM));
1123
1124 pCryptoService = (sal_crypto_service_t *)instanceHandle;
1125
1126 pInstanceInfo->type = CPA_INSTANCE_TYPE_CRYPTO;
1127
1128 /* According to cpa.h instance state is initialized and ready for use
1129 * or shutdown. Therefore need to map our running state to initialised
1130 * or shutdown */
1131 if (SAL_SERVICE_STATE_RUNNING ==
1132 pCryptoService->generic_service_info.state) {
1133 pInstanceInfo->state = CPA_INSTANCE_STATE_INITIALISED;
1134 } else {
1135 pInstanceInfo->state = CPA_INSTANCE_STATE_SHUTDOWN;
1136 }
1137
1138 pGenericService = (sal_service_t *)instanceHandle;
1139 snprintf((char *)pInstanceInfo->name,
1140 CPA_INST_NAME_SIZE,
1141 (char *)name,
1142 pGenericService->instance);
1143
1144 pInstanceInfo->name[CPA_INST_NAME_SIZE - 1] = '\0';
1145
1146 snprintf((char *)pInstanceInfo->version,
1147 CPA_INSTANCE_MAX_NAME_SIZE_IN_BYTES,
1148 "%d.%d",
1149 CPA_CY_API_VERSION_NUM_MAJOR,
1150 CPA_CY_API_VERSION_NUM_MINOR);
1151
1152 pInstanceInfo->version[CPA_INSTANCE_MAX_VERSION_SIZE_IN_BYTES - 1] =
1153 '\0';
1154 return CPA_STATUS_SUCCESS;
1155 }
1156
1157 /**
1158 ******************************************************************************
1159 * @ingroup cpaCyCommon
1160 *****************************************************************************/
1161 CpaStatus
cpaCyInstanceGetInfo2(const CpaInstanceHandle instanceHandle_in,CpaInstanceInfo2 * pInstanceInfo2)1162 cpaCyInstanceGetInfo2(const CpaInstanceHandle instanceHandle_in,
1163 CpaInstanceInfo2 *pInstanceInfo2)
1164 {
1165 CpaInstanceHandle instanceHandle = NULL;
1166 sal_crypto_service_t *pCryptoService = NULL;
1167 icp_accel_dev_t *dev = NULL;
1168 CpaStatus status = CPA_STATUS_SUCCESS;
1169 char keyStr[ADF_CFG_MAX_KEY_LEN_IN_BYTES] = { 0 };
1170 char valStr[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
1171 char *section = DYN_SEC;
1172
1173 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1174 instanceHandle = Lac_CryptoGetFirstHandle();
1175 } else {
1176 instanceHandle = instanceHandle_in;
1177 }
1178
1179 LAC_CHECK_NULL_PARAM(instanceHandle);
1180 LAC_CHECK_NULL_PARAM(pInstanceInfo2);
1181 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1182 (SAL_SERVICE_TYPE_CRYPTO |
1183 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1184 SAL_SERVICE_TYPE_CRYPTO_SYM));
1185
1186 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1187 pInstanceInfo2->accelerationServiceType = CPA_ACC_SVC_TYPE_CRYPTO;
1188 snprintf((char *)pInstanceInfo2->vendorName,
1189 CPA_INST_VENDOR_NAME_SIZE,
1190 "%s",
1191 SAL_INFO2_VENDOR_NAME);
1192 pInstanceInfo2->vendorName[CPA_INST_VENDOR_NAME_SIZE - 1] = '\0';
1193
1194 snprintf((char *)pInstanceInfo2->swVersion,
1195 CPA_INST_SW_VERSION_SIZE,
1196 "Version %d.%d",
1197 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER,
1198 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER);
1199 pInstanceInfo2->swVersion[CPA_INST_SW_VERSION_SIZE - 1] = '\0';
1200
1201 /* Note we can safely read the contents of the crypto service instance
1202 here because icp_amgr_getAllAccelDevByCapabilities() only returns
1203 devs
1204 that have started */
1205 pCryptoService = (sal_crypto_service_t *)instanceHandle;
1206 pInstanceInfo2->physInstId.packageId = pCryptoService->pkgID;
1207 pInstanceInfo2->physInstId.acceleratorId =
1208 pCryptoService->acceleratorNum;
1209 pInstanceInfo2->physInstId.executionEngineId =
1210 pCryptoService->executionEngine;
1211 pInstanceInfo2->physInstId.busAddress =
1212 icp_adf_get_busAddress(pInstanceInfo2->physInstId.packageId);
1213
1214 /*set coreAffinity to zero before use */
1215 LAC_OS_BZERO(pInstanceInfo2->coreAffinity,
1216 sizeof(pInstanceInfo2->coreAffinity));
1217 CPA_BITMAP_BIT_SET(pInstanceInfo2->coreAffinity,
1218 pCryptoService->coreAffinity);
1219 pInstanceInfo2->nodeAffinity = pCryptoService->nodeAffinity;
1220
1221 if (SAL_SERVICE_STATE_RUNNING ==
1222 pCryptoService->generic_service_info.state) {
1223 pInstanceInfo2->operState = CPA_OPER_STATE_UP;
1224 } else {
1225 pInstanceInfo2->operState = CPA_OPER_STATE_DOWN;
1226 }
1227
1228 pInstanceInfo2->requiresPhysicallyContiguousMemory = CPA_TRUE;
1229 if (SAL_RESP_POLL_CFG_FILE == pCryptoService->isPolled) {
1230 pInstanceInfo2->isPolled = CPA_TRUE;
1231 } else {
1232 pInstanceInfo2->isPolled = CPA_FALSE;
1233 }
1234 pInstanceInfo2->isOffloaded = CPA_TRUE;
1235
1236 /* Get the instance name and part name */
1237 dev = icp_adf_getAccelDevByAccelId(pCryptoService->pkgID);
1238 if (NULL == dev ||
1239 0 == strnlen(dev->deviceName, ADF_DEVICE_TYPE_LENGTH + 1)) {
1240 LAC_LOG_ERROR("Can not find device for the instance\n");
1241 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1242 return CPA_STATUS_FAIL;
1243 }
1244 snprintf((char *)pInstanceInfo2->partName,
1245 CPA_INST_PART_NAME_SIZE,
1246 SAL_INFO2_PART_NAME,
1247 dev->deviceName);
1248 pInstanceInfo2->partName[CPA_INST_PART_NAME_SIZE - 1] = '\0';
1249
1250 status =
1251 Sal_StringParsing("Cy",
1252 pCryptoService->generic_service_info.instance,
1253 "Name",
1254 keyStr);
1255 LAC_CHECK_STATUS(status);
1256
1257 if (CPA_FALSE == pCryptoService->generic_service_info.is_dyn) {
1258 section = icpGetProcessName();
1259 }
1260
1261 status = icp_adf_cfgGetParamValue(dev, section, keyStr, valStr);
1262 LAC_CHECK_STATUS(status);
1263
1264 snprintf((char *)pInstanceInfo2->instName,
1265 CPA_INST_NAME_SIZE,
1266 "%s",
1267 valStr);
1268 snprintf((char *)pInstanceInfo2->instID,
1269 CPA_INST_ID_SIZE,
1270 "%s_%s",
1271 section,
1272 valStr);
1273 return CPA_STATUS_SUCCESS;
1274 }
1275
1276 /**
1277 ******************************************************************************
1278 * @ingroup cpaCyCommon
1279 *****************************************************************************/
1280
1281 CpaStatus
cpaCyQueryCapabilities(const CpaInstanceHandle instanceHandle_in,CpaCyCapabilitiesInfo * pCapInfo)1282 cpaCyQueryCapabilities(const CpaInstanceHandle instanceHandle_in,
1283 CpaCyCapabilitiesInfo *pCapInfo)
1284 {
1285 /* Verify Instance exists */
1286 CpaInstanceHandle instanceHandle = NULL;
1287
1288 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1289 instanceHandle = Lac_CryptoGetFirstHandle();
1290 } else {
1291 instanceHandle = instanceHandle_in;
1292 }
1293
1294 LAC_CHECK_NULL_PARAM(instanceHandle);
1295 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1296 (SAL_SERVICE_TYPE_CRYPTO |
1297 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1298 SAL_SERVICE_TYPE_CRYPTO_SYM));
1299 LAC_CHECK_NULL_PARAM(pCapInfo);
1300
1301 SalCtrl_CyQueryCapabilities((sal_service_t *)instanceHandle, pCapInfo);
1302
1303 return CPA_STATUS_SUCCESS;
1304 }
1305
1306 /**
1307 ******************************************************************************
1308 * @ingroup cpaCySym
1309 *****************************************************************************/
1310 CpaStatus
cpaCySymQueryCapabilities(const CpaInstanceHandle instanceHandle_in,CpaCySymCapabilitiesInfo * pCapInfo)1311 cpaCySymQueryCapabilities(const CpaInstanceHandle instanceHandle_in,
1312 CpaCySymCapabilitiesInfo *pCapInfo)
1313 {
1314 sal_crypto_service_t *pCryptoService = NULL;
1315 sal_service_t *pGenericService = NULL;
1316 CpaInstanceHandle instanceHandle = NULL;
1317
1318 /* Verify Instance exists */
1319 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1320 instanceHandle = Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO);
1321 if (!instanceHandle) {
1322 instanceHandle =
1323 Lac_GetFirstHandle(SAL_SERVICE_TYPE_CRYPTO_SYM);
1324 }
1325 } else {
1326 instanceHandle = instanceHandle_in;
1327 }
1328
1329 LAC_CHECK_NULL_PARAM(instanceHandle);
1330 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1331 (SAL_SERVICE_TYPE_CRYPTO |
1332 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1333 SAL_SERVICE_TYPE_CRYPTO_SYM));
1334 LAC_CHECK_NULL_PARAM(pCapInfo);
1335
1336 pCryptoService = (sal_crypto_service_t *)instanceHandle;
1337 pGenericService = &(pCryptoService->generic_service_info);
1338
1339 memset(pCapInfo, '\0', sizeof(CpaCySymCapabilitiesInfo));
1340 /* An asym crypto instance does not support sym service */
1341 if (SAL_SERVICE_TYPE_CRYPTO_ASYM == pGenericService->type) {
1342 return CPA_STATUS_SUCCESS;
1343 }
1344
1345 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_NULL);
1346 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_ECB);
1347 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CBC);
1348 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CTR);
1349 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_CCM);
1350 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_GCM);
1351 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_XTS);
1352 if (isCyGen2x(pCryptoService)) {
1353 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_ARC4);
1354 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1355 CPA_CY_SYM_CIPHER_DES_ECB);
1356 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1357 CPA_CY_SYM_CIPHER_DES_CBC);
1358 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1359 CPA_CY_SYM_CIPHER_3DES_ECB);
1360 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1361 CPA_CY_SYM_CIPHER_3DES_CBC);
1362 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1363 CPA_CY_SYM_CIPHER_3DES_CTR);
1364 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1365 CPA_CY_SYM_CIPHER_KASUMI_F8);
1366 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1367 CPA_CY_SYM_CIPHER_SNOW3G_UEA2);
1368 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_AES_F8);
1369 }
1370
1371 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA1);
1372 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA224);
1373 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA256);
1374 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA384);
1375 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA512);
1376 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_XCBC);
1377 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CCM);
1378 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_GCM);
1379 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CMAC);
1380 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_GMAC);
1381 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_AES_CBC_MAC);
1382 if (isCyGen2x(pCryptoService)) {
1383 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_MD5);
1384 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_KASUMI_F9);
1385 CPA_BITMAP_BIT_SET(pCapInfo->hashes,
1386 CPA_CY_SYM_HASH_SNOW3G_UIA2);
1387 }
1388
1389 if (pGenericService->capabilitiesMask &
1390 ICP_ACCEL_CAPABILITIES_CRYPTO_ZUC) {
1391 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1392 CPA_CY_SYM_CIPHER_ZUC_EEA3);
1393 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_ZUC_EIA3);
1394 }
1395
1396 if (pGenericService->capabilitiesMask &
1397 ICP_ACCEL_CAPABILITIES_CHACHA_POLY) {
1398 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_POLY);
1399 CPA_BITMAP_BIT_SET(pCapInfo->ciphers, CPA_CY_SYM_CIPHER_CHACHA);
1400 }
1401
1402 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SM3) {
1403 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SM3);
1404 }
1405
1406 pCapInfo->partialPacketSupported = CPA_TRUE;
1407
1408 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SHA3) {
1409 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_256);
1410 pCapInfo->partialPacketSupported = CPA_FALSE;
1411 }
1412
1413 if (pGenericService->capabilitiesMask &
1414 ICP_ACCEL_CAPABILITIES_SHA3_EXT) {
1415 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_224);
1416 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_256);
1417 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_384);
1418 CPA_BITMAP_BIT_SET(pCapInfo->hashes, CPA_CY_SYM_HASH_SHA3_512);
1419 pCapInfo->partialPacketSupported = CPA_FALSE;
1420 }
1421
1422 if (pGenericService->capabilitiesMask & ICP_ACCEL_CAPABILITIES_SM4) {
1423 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1424 CPA_CY_SYM_CIPHER_SM4_ECB);
1425 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1426 CPA_CY_SYM_CIPHER_SM4_CBC);
1427 CPA_BITMAP_BIT_SET(pCapInfo->ciphers,
1428 CPA_CY_SYM_CIPHER_SM4_CTR);
1429 pCapInfo->partialPacketSupported = CPA_FALSE;
1430 }
1431
1432 return CPA_STATUS_SUCCESS;
1433 }
1434
1435 /**
1436 ******************************************************************************
1437 * @ingroup cpaCyCommon
1438 *****************************************************************************/
1439 CpaStatus
cpaCySetAddressTranslation(const CpaInstanceHandle instanceHandle_in,CpaVirtualToPhysical virtual2physical)1440 cpaCySetAddressTranslation(const CpaInstanceHandle instanceHandle_in,
1441 CpaVirtualToPhysical virtual2physical)
1442 {
1443
1444 CpaInstanceHandle instanceHandle = NULL;
1445 sal_service_t *pService = NULL;
1446
1447 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1448 instanceHandle = Lac_CryptoGetFirstHandle();
1449 } else {
1450 instanceHandle = instanceHandle_in;
1451 }
1452
1453 LAC_CHECK_NULL_PARAM(instanceHandle);
1454 SAL_CHECK_INSTANCE_TYPE(instanceHandle,
1455 (SAL_SERVICE_TYPE_CRYPTO |
1456 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1457 SAL_SERVICE_TYPE_CRYPTO_SYM));
1458 LAC_CHECK_NULL_PARAM(virtual2physical);
1459
1460 pService = (sal_service_t *)instanceHandle;
1461
1462 pService->virt2PhysClient = virtual2physical;
1463
1464 return CPA_STATUS_SUCCESS;
1465 }
1466
1467 /**
1468 ******************************************************************************
1469 * @ingroup cpaCyCommon
1470 * Crypto specific polling function which polls a crypto instance.
1471 *****************************************************************************/
1472 CpaStatus
icp_sal_CyPollInstance(CpaInstanceHandle instanceHandle_in,Cpa32U response_quota)1473 icp_sal_CyPollInstance(CpaInstanceHandle instanceHandle_in,
1474 Cpa32U response_quota)
1475 {
1476 CpaStatus status = CPA_STATUS_SUCCESS;
1477 sal_crypto_service_t *crypto_handle = NULL;
1478 sal_service_t *gen_handle = NULL;
1479 icp_comms_trans_handle trans_hndTable[MAX_CY_RX_RINGS] = { 0 };
1480 Cpa32U num_rx_rings = 0;
1481
1482 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1483 crypto_handle =
1484 (sal_crypto_service_t *)Lac_CryptoGetFirstHandle();
1485 } else {
1486 crypto_handle = (sal_crypto_service_t *)instanceHandle_in;
1487 }
1488 LAC_CHECK_NULL_PARAM(crypto_handle);
1489 SAL_RUNNING_CHECK(crypto_handle);
1490 SAL_CHECK_INSTANCE_TYPE(crypto_handle,
1491 (SAL_SERVICE_TYPE_CRYPTO |
1492 SAL_SERVICE_TYPE_CRYPTO_ASYM |
1493 SAL_SERVICE_TYPE_CRYPTO_SYM));
1494
1495 gen_handle = &(crypto_handle->generic_service_info);
1496
1497 /*
1498 * From the instanceHandle we must get the trans_handle and send
1499 * down to adf for polling.
1500 * Populate our trans handle table with the appropriate handles.
1501 */
1502
1503 switch (gen_handle->type) {
1504 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
1505 trans_hndTable[TH_CY_RX_0] =
1506 crypto_handle->trans_handle_asym_rx;
1507 num_rx_rings = 1;
1508 break;
1509 case SAL_SERVICE_TYPE_CRYPTO_SYM:
1510 trans_hndTable[TH_CY_RX_0] = crypto_handle->trans_handle_sym_rx;
1511 num_rx_rings = 1;
1512 break;
1513 case SAL_SERVICE_TYPE_CRYPTO:
1514 trans_hndTable[TH_CY_RX_0] = crypto_handle->trans_handle_sym_rx;
1515 trans_hndTable[TH_CY_RX_1] =
1516 crypto_handle->trans_handle_asym_rx;
1517 num_rx_rings = MAX_CY_RX_RINGS;
1518 break;
1519 default:
1520 break;
1521 }
1522
1523 /* Call adf to do the polling. */
1524 status =
1525 icp_adf_pollInstance(trans_hndTable, num_rx_rings, response_quota);
1526
1527 return status;
1528 }
1529
1530 /**
1531 ******************************************************************************
1532 * @ingroup cpaCyCommon
1533 * Crypto specific polling function which polls sym crypto ring.
1534 *****************************************************************************/
1535 CpaStatus
icp_sal_CyPollSymRing(CpaInstanceHandle instanceHandle_in,Cpa32U response_quota)1536 icp_sal_CyPollSymRing(CpaInstanceHandle instanceHandle_in,
1537 Cpa32U response_quota)
1538 {
1539 CpaStatus status = CPA_STATUS_SUCCESS;
1540 sal_crypto_service_t *crypto_handle = NULL;
1541 icp_comms_trans_handle trans_hndTable[NUM_CRYPTO_SYM_RX_RINGS] = { 0 };
1542
1543 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1544 crypto_handle = (sal_crypto_service_t *)Lac_GetFirstHandle(
1545 SAL_SERVICE_TYPE_CRYPTO_SYM);
1546 } else {
1547 crypto_handle = (sal_crypto_service_t *)instanceHandle_in;
1548 }
1549 LAC_CHECK_NULL_PARAM(crypto_handle);
1550 SAL_CHECK_INSTANCE_TYPE(crypto_handle,
1551 (SAL_SERVICE_TYPE_CRYPTO |
1552 SAL_SERVICE_TYPE_CRYPTO_SYM));
1553 SAL_RUNNING_CHECK(crypto_handle);
1554
1555 /*
1556 * From the instanceHandle we must get the trans_handle and send
1557 * down to adf for polling.
1558 * Populate our trans handle table with the appropriate handles.
1559 */
1560 trans_hndTable[TH_SINGLE_RX] = crypto_handle->trans_handle_sym_rx;
1561 /* Call adf to do the polling. */
1562 status = icp_adf_pollInstance(trans_hndTable,
1563 NUM_CRYPTO_SYM_RX_RINGS,
1564 response_quota);
1565 return status;
1566 }
1567
1568 /**
1569 ******************************************************************************
1570 * @ingroup cpaCyCommon
1571 * Crypto specific polling function which polls an nrbg crypto ring.
1572 *****************************************************************************/
1573 CpaStatus
icp_sal_CyPollNRBGRing(CpaInstanceHandle instanceHandle_in,Cpa32U response_quota)1574 icp_sal_CyPollNRBGRing(CpaInstanceHandle instanceHandle_in,
1575 Cpa32U response_quota)
1576 {
1577 return CPA_STATUS_UNSUPPORTED;
1578 }
1579
1580 /* Returns the handle to the first asym crypto instance */
1581 static CpaInstanceHandle
Lac_GetFirstAsymHandle(icp_accel_dev_t * adfInsts[ADF_MAX_DEVICES],Cpa16U num_dev)1582 Lac_GetFirstAsymHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES],
1583 Cpa16U num_dev)
1584 {
1585 CpaStatus status = CPA_STATUS_SUCCESS;
1586 icp_accel_dev_t *dev_addr = NULL;
1587 sal_t *base_addr = NULL;
1588 sal_list_t *list_temp = NULL;
1589 CpaInstanceHandle cyInst = NULL;
1590 CpaInstanceInfo2 info;
1591 Cpa16U i = 0;
1592
1593 for (i = 0; i < num_dev; i++) {
1594 dev_addr = (icp_accel_dev_t *)adfInsts[i];
1595 base_addr = dev_addr->pSalHandle;
1596 if (NULL == base_addr) {
1597 continue;
1598 }
1599 list_temp = base_addr->asym_services;
1600 while (NULL != list_temp) {
1601 cyInst = SalList_getObject(list_temp);
1602 status = cpaCyInstanceGetInfo2(cyInst, &info);
1603 list_temp = SalList_next(list_temp);
1604 if (CPA_STATUS_SUCCESS != status ||
1605 CPA_TRUE != info.isPolled) {
1606 cyInst = NULL;
1607 continue;
1608 }
1609 break;
1610 }
1611 if (cyInst) {
1612 break;
1613 }
1614 }
1615
1616 return cyInst;
1617 }
1618
1619 /* Returns the handle to the first sym crypto instance */
1620 static CpaInstanceHandle
Lac_GetFirstSymHandle(icp_accel_dev_t * adfInsts[ADF_MAX_DEVICES],Cpa16U num_dev)1621 Lac_GetFirstSymHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES],
1622 Cpa16U num_dev)
1623 {
1624 CpaStatus status = CPA_STATUS_SUCCESS;
1625 icp_accel_dev_t *dev_addr = NULL;
1626 sal_t *base_addr = NULL;
1627 sal_list_t *list_temp = NULL;
1628 CpaInstanceHandle cyInst = NULL;
1629 CpaInstanceInfo2 info;
1630 Cpa16U i = 0;
1631
1632 for (i = 0; i < num_dev; i++) {
1633 dev_addr = (icp_accel_dev_t *)adfInsts[i];
1634 base_addr = dev_addr->pSalHandle;
1635 if (NULL == base_addr) {
1636 continue;
1637 }
1638 list_temp = base_addr->sym_services;
1639 while (NULL != list_temp) {
1640 cyInst = SalList_getObject(list_temp);
1641 status = cpaCyInstanceGetInfo2(cyInst, &info);
1642 list_temp = SalList_next(list_temp);
1643 if (CPA_STATUS_SUCCESS != status ||
1644 CPA_TRUE != info.isPolled) {
1645 cyInst = NULL;
1646 continue;
1647 }
1648 break;
1649 }
1650 if (cyInst) {
1651 break;
1652 }
1653 }
1654
1655 return cyInst;
1656 }
1657
1658 /* Returns the handle to the first crypto instance
1659 * Note that the crypto instance in this case supports
1660 * both asym and sym services */
1661 static CpaInstanceHandle
Lac_GetFirstCyHandle(icp_accel_dev_t * adfInsts[ADF_MAX_DEVICES],Cpa16U num_dev)1662 Lac_GetFirstCyHandle(icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES], Cpa16U num_dev)
1663 {
1664 CpaStatus status = CPA_STATUS_SUCCESS;
1665 icp_accel_dev_t *dev_addr = NULL;
1666 sal_t *base_addr = NULL;
1667 sal_list_t *list_temp = NULL;
1668 CpaInstanceHandle cyInst = NULL;
1669 CpaInstanceInfo2 info;
1670 Cpa16U i = 0;
1671
1672 for (i = 0; i < num_dev; i++) {
1673 dev_addr = (icp_accel_dev_t *)adfInsts[i];
1674 base_addr = dev_addr->pSalHandle;
1675 if (NULL == base_addr) {
1676 continue;
1677 }
1678 list_temp = base_addr->crypto_services;
1679 while (NULL != list_temp) {
1680 cyInst = SalList_getObject(list_temp);
1681 status = cpaCyInstanceGetInfo2(cyInst, &info);
1682 list_temp = SalList_next(list_temp);
1683 if (CPA_STATUS_SUCCESS != status ||
1684 CPA_TRUE != info.isPolled) {
1685 cyInst = NULL;
1686 continue;
1687 }
1688 break;
1689 }
1690 if (cyInst) {
1691 break;
1692 }
1693 }
1694
1695 return cyInst;
1696 }
1697
1698 CpaInstanceHandle
Lac_GetFirstHandle(sal_service_type_t svc_type)1699 Lac_GetFirstHandle(sal_service_type_t svc_type)
1700 {
1701 CpaStatus status = CPA_STATUS_SUCCESS;
1702 static icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES] = { 0 };
1703 CpaInstanceHandle cyInst = NULL;
1704 Cpa16U num_cy_dev = 0;
1705 Cpa32U capabilities = 0;
1706
1707 switch (svc_type) {
1708 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
1709 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
1710 break;
1711 case SAL_SERVICE_TYPE_CRYPTO_SYM:
1712 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC;
1713 break;
1714 case SAL_SERVICE_TYPE_CRYPTO:
1715 capabilities = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
1716 capabilities |= ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC;
1717 break;
1718 default:
1719 LAC_LOG_ERROR("Invalid service type\n");
1720 return NULL;
1721 }
1722 /* Only need 1 dev with crypto enabled - so check all devices*/
1723 status = icp_amgr_getAllAccelDevByEachCapability(capabilities,
1724 adfInsts,
1725 &num_cy_dev);
1726 if ((0 == num_cy_dev) || (CPA_STATUS_SUCCESS != status)) {
1727 LAC_LOG_ERROR("No crypto devices enabled in the system\n");
1728 return NULL;
1729 }
1730
1731 switch (svc_type) {
1732 case SAL_SERVICE_TYPE_CRYPTO_ASYM:
1733 /* Try to find an asym only instance first */
1734 cyInst = Lac_GetFirstAsymHandle(adfInsts, num_cy_dev);
1735 /* Try to find a cy instance since it also supports asym */
1736 if (NULL == cyInst) {
1737 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev);
1738 }
1739 break;
1740 case SAL_SERVICE_TYPE_CRYPTO_SYM:
1741 /* Try to find a sym only instance first */
1742 cyInst = Lac_GetFirstSymHandle(adfInsts, num_cy_dev);
1743 /* Try to find a cy instance since it also supports sym */
1744 if (NULL == cyInst) {
1745 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev);
1746 }
1747 break;
1748 case SAL_SERVICE_TYPE_CRYPTO:
1749 /* Try to find a cy instance */
1750 cyInst = Lac_GetFirstCyHandle(adfInsts, num_cy_dev);
1751 break;
1752 default:
1753 break;
1754 }
1755 if (NULL == cyInst) {
1756 LAC_LOG_ERROR("No remaining crypto instances available\n");
1757 }
1758 return cyInst;
1759 }
1760
1761 CpaStatus
icp_sal_NrbgGetInflightRequests(CpaInstanceHandle instanceHandle_in,Cpa32U * maxInflightRequests,Cpa32U * numInflightRequests)1762 icp_sal_NrbgGetInflightRequests(CpaInstanceHandle instanceHandle_in,
1763 Cpa32U *maxInflightRequests,
1764 Cpa32U *numInflightRequests)
1765 {
1766 return CPA_STATUS_UNSUPPORTED;
1767 }
1768
1769 CpaStatus
icp_sal_SymGetInflightRequests(CpaInstanceHandle instanceHandle,Cpa32U * maxInflightRequests,Cpa32U * numInflightRequests)1770 icp_sal_SymGetInflightRequests(CpaInstanceHandle instanceHandle,
1771 Cpa32U *maxInflightRequests,
1772 Cpa32U *numInflightRequests)
1773 {
1774 sal_crypto_service_t *crypto_handle = NULL;
1775
1776 crypto_handle = (sal_crypto_service_t *)instanceHandle;
1777
1778 LAC_CHECK_NULL_PARAM(crypto_handle);
1779 LAC_CHECK_NULL_PARAM(maxInflightRequests);
1780 LAC_CHECK_NULL_PARAM(numInflightRequests);
1781 SAL_RUNNING_CHECK(crypto_handle);
1782
1783 return icp_adf_getInflightRequests(crypto_handle->trans_handle_sym_tx,
1784 maxInflightRequests,
1785 numInflightRequests);
1786 }
1787
1788 CpaStatus
icp_sal_dp_SymGetInflightRequests(CpaInstanceHandle instanceHandle,Cpa32U * maxInflightRequests,Cpa32U * numInflightRequests)1789 icp_sal_dp_SymGetInflightRequests(CpaInstanceHandle instanceHandle,
1790 Cpa32U *maxInflightRequests,
1791 Cpa32U *numInflightRequests)
1792 {
1793 sal_crypto_service_t *crypto_handle = NULL;
1794
1795 crypto_handle = (sal_crypto_service_t *)instanceHandle;
1796
1797 return icp_adf_dp_getInflightRequests(
1798 crypto_handle->trans_handle_sym_tx,
1799 maxInflightRequests,
1800 numInflightRequests);
1801 }
1802
1803 CpaStatus
icp_sal_setForceAEADMACVerify(CpaInstanceHandle instanceHandle,CpaBoolean forceAEADMacVerify)1804 icp_sal_setForceAEADMACVerify(CpaInstanceHandle instanceHandle,
1805 CpaBoolean forceAEADMacVerify)
1806 {
1807 sal_crypto_service_t *crypto_handle = NULL;
1808
1809 crypto_handle = (sal_crypto_service_t *)instanceHandle;
1810 LAC_CHECK_NULL_PARAM(crypto_handle);
1811 crypto_handle->forceAEADMacVerify = forceAEADMacVerify;
1812
1813 return CPA_STATUS_SUCCESS;
1814 }
1815