1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* Copyright(c) 2007-2022 Intel Corporation */ 3 /** 4 ***************************************************************************** 5 * @file sal_ctrl_services.c 6 * 7 * @ingroup SalCtrl 8 * 9 * @description 10 * This file contains the core of the service controller implementation. 11 * 12 *****************************************************************************/ 13 14 /* QAT-API includes */ 15 #include "cpa.h" 16 #include "cpa_cy_key.h" 17 #include "cpa_cy_ln.h" 18 #include "cpa_cy_dh.h" 19 #include "cpa_cy_dsa.h" 20 #include "cpa_cy_rsa.h" 21 #include "cpa_cy_ec.h" 22 #include "cpa_cy_prime.h" 23 #include "cpa_cy_sym.h" 24 #include "cpa_dc.h" 25 26 /* QAT utils includes */ 27 #include "qat_utils.h" 28 29 /* ADF includes */ 30 #include "icp_adf_init.h" 31 #include "icp_adf_transport.h" 32 #include "icp_accel_devices.h" 33 #include "icp_adf_cfg.h" 34 #include "icp_adf_init.h" 35 #include "icp_adf_accel_mgr.h" 36 #include "icp_adf_debug.h" 37 38 /* FW includes */ 39 #include "icp_qat_fw_la.h" 40 41 /* SAL includes */ 42 #include "lac_mem.h" 43 #include "lac_mem_pools.h" 44 #include "lac_list.h" 45 #include "lac_hooks.h" 46 #include "sal_string_parse.h" 47 #include "lac_common.h" 48 #include "lac_sal_types.h" 49 #include "lac_sal.h" 50 #include "lac_sal_ctrl.h" 51 #include "icp_sal_versions.h" 52 53 #define MAX_SUBSYSTEM_RETRY 64 54 55 static char *subsystem_name = "SAL"; 56 /**< Name used by ADF to identify this component. */ 57 static char *cy_dir_name = "cy"; 58 static char *asym_dir_name = "asym"; 59 static char *sym_dir_name = "sym"; 60 static char *dc_dir_name = "dc"; 61 /**< Stats dir names. */ 62 static char *ver_file_name = "version"; 63 64 static subservice_registation_handle_t sal_service_reg_handle; 65 /**< Data structure used by ADF to keep a reference to this component. */ 66 67 /* 68 * @ingroup SalCtrl 69 * @description 70 * This function is used to parse the results from ADF 71 * in response to ServiceEnabled query.The results are 72 * semi-colon separated. Internally, the bitmask represented 73 * by the enabled_service is used to track which features are enabled. 74 * 75 * @context 76 * This functions is called from the SalCtrl_ServiceEventInit function. 77 * 78 * @assumptions 79 * None 80 * @sideEffects 81 * None 82 * @reentrant 83 * No 84 * @threadSafe 85 * Yes 86 * 87 * @param[in] device pointer to icp_accel_dev_t structure 88 * @param[in] pEnabledServices pointer to memory where enabled services will 89 * be written. 90 * @retval Status 91 */ 92 CpaStatus 93 SalCtrl_GetEnabledServices(icp_accel_dev_t *device, Cpa32U *pEnabledServices) 94 { 95 CpaStatus status = CPA_STATUS_SUCCESS; 96 char param_value[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 97 char *token = NULL; 98 char *running = NULL; 99 100 *pEnabledServices = 0; 101 102 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 103 status = icp_adf_cfgGetParamValue(device, 104 LAC_CFG_SECTION_GENERAL, 105 "ServicesEnabled", 106 param_value); 107 108 if (CPA_STATUS_SUCCESS == status) { 109 running = param_value; 110 111 token = strsep(&running, ";"); 112 113 while (NULL != token) { 114 do { 115 if (strncmp(token, "asym", strlen("asym")) == 116 0) { 117 *pEnabledServices |= 118 SAL_SERVICE_TYPE_CRYPTO_ASYM; 119 break; 120 } 121 if (strncmp(token, "sym", strlen("sym")) == 0) { 122 *pEnabledServices |= 123 SAL_SERVICE_TYPE_CRYPTO_SYM; 124 break; 125 } 126 if (strncmp(token, "cy", strlen("cy")) == 0) { 127 *pEnabledServices |= 128 SAL_SERVICE_TYPE_CRYPTO; 129 break; 130 } 131 if (strncmp(token, "dc", strlen("dc")) == 0) { 132 *pEnabledServices |= 133 SAL_SERVICE_TYPE_COMPRESSION; 134 break; 135 } 136 137 QAT_UTILS_LOG( 138 "Error parsing enabled services from ADF.\n"); 139 return CPA_STATUS_FAIL; 140 141 } while (0); 142 token = strsep(&running, ";"); 143 } 144 } else { 145 QAT_UTILS_LOG("Failed to get enabled services from ADF.\n"); 146 } 147 return status; 148 } 149 150 /* 151 * @ingroup SalCtrl 152 * @description 153 * This function is used to check whether a service is enabled 154 * 155 * @context 156 * This functions is called from the SalCtrl_ServiceEventInit function. 157 * 158 * @assumptions 159 * None 160 * @sideEffects 161 * None 162 * @reentrant 163 * No 164 * @threadSafe 165 * Yes 166 * 167 * param[in] enabled_services It is the bitmask for the enabled services 168 * param[in] service It is the service we want to check for 169 */ 170 CpaBoolean 171 SalCtrl_IsServiceEnabled(Cpa32U enabled_services, sal_service_type_t service) 172 { 173 return (CpaBoolean)((enabled_services & (Cpa32U)(service)) != 0); 174 } 175 176 /* 177 * @ingroup SalCtrl 178 * @description 179 * This function is used to check whether enabled services has associated 180 * hardware capability support 181 * 182 * @context 183 * This functions is called from the SalCtrl_ServiceEventInit function. 184 * 185 * @assumptions 186 * None 187 * @sideEffects 188 * None 189 * @reentrant 190 * No 191 * @threadSafe 192 * Yes 193 * 194 * param[in] device A pointer to an icp_accel_dev_t 195 * param[in] enabled_services It is the bitmask for the enabled services 196 */ 197 198 CpaStatus 199 SalCtrl_GetSupportedServices(icp_accel_dev_t *device, Cpa32U enabled_services) 200 { 201 CpaStatus status = CPA_STATUS_SUCCESS; 202 Cpa32U capabilitiesMask = 0; 203 204 status = icp_amgr_getAccelDevCapabilities(device, &capabilitiesMask); 205 206 if (CPA_STATUS_SUCCESS == status) { 207 if (SalCtrl_IsServiceEnabled(enabled_services, 208 SAL_SERVICE_TYPE_CRYPTO)) { 209 if (!(capabilitiesMask & 210 ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC) || 211 !(capabilitiesMask & 212 ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC)) { 213 QAT_UTILS_LOG( 214 "Device does not support Crypto service\n"); 215 status = CPA_STATUS_FAIL; 216 } 217 } 218 if (SalCtrl_IsServiceEnabled(enabled_services, 219 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 220 if (!(capabilitiesMask & 221 ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC)) { 222 QAT_UTILS_LOG( 223 "Device does not support Asym service\n"); 224 status = CPA_STATUS_FAIL; 225 } 226 } 227 if (SalCtrl_IsServiceEnabled(enabled_services, 228 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 229 if (!(capabilitiesMask & 230 ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC)) { 231 QAT_UTILS_LOG( 232 "Device does not support Sym service\n"); 233 status = CPA_STATUS_FAIL; 234 } 235 } 236 if (SalCtrl_IsServiceEnabled(enabled_services, 237 SAL_SERVICE_TYPE_COMPRESSION)) { 238 if (!(capabilitiesMask & 239 ICP_ACCEL_CAPABILITIES_COMPRESSION)) { 240 QAT_UTILS_LOG( 241 "Device does not support Compression service.\n"); 242 status = CPA_STATUS_FAIL; 243 } 244 } 245 } 246 247 return status; 248 } 249 250 /************************************************************************* 251 * @ingroup SalCtrl 252 * @description 253 * This function is used to check if a service is supported 254 * on the device. The key difference between this and 255 * SalCtrl_GetSupportedServices() is that the latter treats it as 256 * an error if the service is unsupported. 257 * 258 * @context 259 * This can be called anywhere. 260 * 261 * @assumptions 262 * None 263 * @sideEffects 264 * None 265 * @reentrant 266 * No 267 * @threadSafe 268 * Yes 269 * 270 * param[in] device 271 * param[in] service service or services to check 272 * 273 *************************************************************************/ 274 CpaBoolean 275 SalCtrl_IsServiceSupported(icp_accel_dev_t *device, 276 sal_service_type_t service_to_check) 277 { 278 CpaStatus status = CPA_STATUS_SUCCESS; 279 Cpa32U capabilitiesMask = 0; 280 CpaBoolean service_supported = CPA_TRUE; 281 282 if (!(SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 283 SAL_SERVICE_TYPE_CRYPTO)) && 284 !(SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 285 SAL_SERVICE_TYPE_CRYPTO_ASYM)) && 286 !(SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 287 SAL_SERVICE_TYPE_CRYPTO_SYM)) && 288 !(SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 289 SAL_SERVICE_TYPE_COMPRESSION))) { 290 QAT_UTILS_LOG("Invalid service type\n"); 291 service_supported = CPA_FALSE; 292 } 293 294 status = icp_amgr_getAccelDevCapabilities(device, &capabilitiesMask); 295 296 if (CPA_STATUS_SUCCESS != status) { 297 QAT_UTILS_LOG("Can not get device capabilities.\n"); 298 return CPA_FALSE; 299 } 300 301 if (SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 302 SAL_SERVICE_TYPE_CRYPTO)) { 303 if (!(capabilitiesMask & 304 ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC) || 305 !(capabilitiesMask & 306 ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC)) { 307 QAT_UTILS_LOG( 308 "Device does not support Crypto service\n"); 309 service_supported = CPA_FALSE; 310 } 311 } 312 if (SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 313 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 314 if (!(capabilitiesMask & 315 ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC)) { 316 QAT_UTILS_LOG("Device does not support Asym service\n"); 317 service_supported = CPA_FALSE; 318 } 319 } 320 if (SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 321 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 322 if (!(capabilitiesMask & 323 ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC)) { 324 QAT_UTILS_LOG("Device does not support Sym service\n"); 325 service_supported = CPA_FALSE; 326 } 327 } 328 if (SalCtrl_IsServiceEnabled((Cpa32U)service_to_check, 329 SAL_SERVICE_TYPE_COMPRESSION)) { 330 if (!(capabilitiesMask & ICP_ACCEL_CAPABILITIES_COMPRESSION)) { 331 QAT_UTILS_LOG( 332 "Device does not support Compression service.\n"); 333 service_supported = CPA_FALSE; 334 } 335 } 336 337 return service_supported; 338 } 339 340 /* 341 * @ingroup SalCtrl 342 * @description 343 * This function is used to retrieve how many instances are 344 * to be configured for process specific service. 345 * 346 * @context 347 * This functions is called from the SalCtrl_ServiceEventInit function. 348 * 349 * @assumptions 350 * None 351 * @sideEffects 352 * None 353 * @reentrant 354 * No 355 * @threadSafe 356 * Yes 357 * 358 * @param[in] device A pointer to an icp_accel_dev_t 359 * @param[in] key Represents the parameter's name we want to query 360 * @param[out] pCount Pointer to memory where num instances will be stored 361 * @retval status returned status from ADF or _FAIL if number of instances 362 * is out of range for the device. 363 */ 364 static CpaStatus 365 SalCtrl_GetInstanceCount(icp_accel_dev_t *device, char *key, Cpa32U *pCount) 366 { 367 CpaStatus status = CPA_STATUS_FAIL; 368 char param_value[ADF_CFG_MAX_VAL_LEN_IN_BYTES]; 369 370 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 371 status = icp_adf_cfgGetParamValue(device, 372 icpGetProcessName(), 373 key, 374 param_value); 375 if (CPA_STATUS_SUCCESS == status) { 376 *pCount = 377 (Cpa32U)(Sal_Strtoul(param_value, NULL, SAL_CFG_BASE_DEC)); 378 if (*pCount > SAL_MAX_NUM_INSTANCES_PER_DEV) { 379 QAT_UTILS_LOG("Number of instances is out of range.\n"); 380 status = CPA_STATUS_FAIL; 381 } 382 } 383 return status; 384 } 385 386 /************************************************************************** 387 * @ingroup SalCtrl 388 * @description 389 * This function calls the shutdown function on all the 390 * service instances. 391 * It also frees all service instance memory allocated at Init. 392 * 393 * @context 394 * This function is called from the SalCtrl_ServiceEventShutdown 395 * function. 396 * 397 * @assumptions 398 * params[in] should not be NULL 399 * @sideEffects 400 * None 401 * @reentrant 402 * No 403 * @threadSafe 404 * Yes 405 * 406 * @param[in] device An icp_accel_dev_t* type 407 * @param[in] services A pointer to the container of services 408 * @param[in] dbg_dir A pointer to the debug directory 409 * @param[in] svc_type The type of the service instance 410 * 411 ****************************************************************************/ 412 static CpaStatus 413 SalCtrl_ServiceShutdown(icp_accel_dev_t *device, 414 sal_list_t **services, 415 debug_dir_info_t **debug_dir, 416 sal_service_type_t svc_type) 417 { 418 CpaStatus status = CPA_STATUS_SUCCESS; 419 sal_list_t *dyn_service = NULL; 420 sal_service_t *inst = NULL; 421 422 /* Call Shutdown function for each service instance */ 423 SAL_FOR_EACH(*services, sal_service_t, device, shutdown, status); 424 425 if (*debug_dir) { 426 icp_adf_debugRemoveDir(*debug_dir); 427 LAC_OS_FREE(*debug_dir); 428 *debug_dir = NULL; 429 } 430 431 if (!icp_adf_is_dev_in_reset(device)) { 432 dyn_service = *services; 433 while (dyn_service) { 434 inst = (sal_service_t *)SalList_getObject(dyn_service); 435 if (CPA_TRUE == inst->is_dyn) { 436 icp_adf_putDynInstance(device, 437 (adf_service_type_t) 438 svc_type, 439 inst->instance); 440 } 441 dyn_service = SalList_next(dyn_service); 442 } 443 /* Free Sal services controller memory */ 444 SalList_free(services); 445 } else { 446 sal_list_t *curr_element = NULL; 447 sal_service_t *service = NULL; 448 curr_element = *services; 449 while (NULL != curr_element) { 450 service = 451 (sal_service_t *)SalList_getObject(curr_element); 452 service->state = SAL_SERVICE_STATE_RESTARTING; 453 curr_element = SalList_next(curr_element); 454 } 455 } 456 457 return status; 458 } 459 460 static CpaStatus 461 selectGeneration(device_type_t deviceType, sal_service_t *pInst) 462 { 463 switch (deviceType) { 464 case DEVICE_C62X: 465 case DEVICE_C62XVF: 466 case DEVICE_DH895XCC: 467 case DEVICE_DH895XCCVF: 468 case DEVICE_C3XXX: 469 case DEVICE_C3XXXVF: 470 case DEVICE_200XX: 471 case DEVICE_200XXVF: 472 pInst->gen = GEN2; 473 break; 474 475 case DEVICE_C4XXX: 476 case DEVICE_C4XXXVF: 477 pInst->gen = GEN3; 478 break; 479 480 case DEVICE_4XXX: 481 case DEVICE_4XXXVF: 482 pInst->gen = GEN4; 483 break; 484 485 default: 486 QAT_UTILS_LOG("deviceType not initialised\n"); 487 return CPA_STATUS_FAIL; 488 } 489 return CPA_STATUS_SUCCESS; 490 } 491 492 /************************************************************************* 493 * @ingroup SalCtrl 494 * @description 495 * This function is used to initialise the service instances. 496 * It allocates memory for service instances and invokes the 497 * Init function on them. 498 * 499 * @context 500 * This function is called from the SalCtrl_ServiceEventInit function. 501 * 502 * @assumptions 503 * None 504 * @sideEffects 505 * None 506 * @reentrant 507 * No 508 * @threadSafe 509 * Yes 510 * 511 * @param[in] device An icp_accel_dev_t* type 512 * @param[in] services A pointer to the container of services 513 * @param[in] dbg_dir A pointer to the debug directory 514 * @param[in] dbg_dir_name Name of the debug directory 515 * @param[in] tail_list SAL's list of services 516 * @param[in] instance_count Number of instances 517 * @param[in] svc_type The type of the service instance 518 * 519 *************************************************************************/ 520 static CpaStatus 521 SalCtrl_ServiceInit(icp_accel_dev_t *device, 522 sal_list_t **services, 523 debug_dir_info_t **dbg_dir, 524 char *dbg_dir_name, 525 sal_list_t *tail_list, 526 Cpa32U instance_count, 527 sal_service_type_t svc_type) 528 { 529 CpaStatus status = CPA_STATUS_SUCCESS; 530 sal_service_t *pInst = NULL; 531 Cpa32U i = 0; 532 debug_dir_info_t *debug_dir = NULL; 533 534 debug_dir = LAC_OS_MALLOC(sizeof(debug_dir_info_t)); 535 if (NULL == debug_dir) { 536 QAT_UTILS_LOG("Failed to allocate memory for debug dir.\n"); 537 return CPA_STATUS_RESOURCE; 538 } 539 debug_dir->name = dbg_dir_name; 540 debug_dir->parent = NULL; 541 status = icp_adf_debugAddDir(device, debug_dir); 542 if (CPA_STATUS_SUCCESS != status) { 543 QAT_UTILS_LOG("Failed to add debug dir.\n"); 544 LAC_OS_FREE(debug_dir); 545 debug_dir = NULL; 546 return status; 547 } 548 549 if (!icp_adf_is_dev_in_reset(device)) { 550 for (i = 0; i < instance_count; i++) { 551 status = SalCtrl_ServiceCreate(svc_type, i, &pInst); 552 if (CPA_STATUS_SUCCESS != status) { 553 break; 554 } 555 pInst->debug_parent_dir = debug_dir; 556 pInst->capabilitiesMask = device->accelCapabilitiesMask; 557 558 status = selectGeneration(device->deviceType, pInst); 559 if (CPA_STATUS_SUCCESS == status) { 560 status = 561 SalList_add(services, &tail_list, pInst); 562 } 563 if (CPA_STATUS_SUCCESS != status) { 564 free(pInst, M_QAT); 565 } 566 } 567 } else { 568 sal_list_t *curr_element = *services; 569 sal_service_t *service = NULL; 570 while (NULL != curr_element) { 571 service = 572 (sal_service_t *)SalList_getObject(curr_element); 573 service->debug_parent_dir = debug_dir; 574 575 if (CPA_TRUE == service->isInstanceStarted) { 576 icp_qa_dev_get(device); 577 } 578 579 curr_element = SalList_next(curr_element); 580 } 581 } 582 583 if (CPA_STATUS_SUCCESS != status) { 584 QAT_UTILS_LOG("Failed to allocate all instances.\n"); 585 icp_adf_debugRemoveDir(debug_dir); 586 LAC_OS_FREE(debug_dir); 587 debug_dir = NULL; 588 SalList_free(services); 589 return status; 590 } 591 592 /* Call init function for each service instance */ 593 SAL_FOR_EACH(*services, sal_service_t, device, init, status); 594 if (CPA_STATUS_SUCCESS != status) { 595 QAT_UTILS_LOG("Failed to initialise all service instances.\n"); 596 /* shutdown all instances initialised before error */ 597 SAL_FOR_EACH_STATE(*services, 598 sal_service_t, 599 device, 600 shutdown, 601 SAL_SERVICE_STATE_INITIALIZED); 602 icp_adf_debugRemoveDir(debug_dir); 603 LAC_OS_FREE(debug_dir); 604 debug_dir = NULL; 605 SalList_free(services); 606 return status; 607 } 608 /* initialize the debug directory for relevant service */ 609 *dbg_dir = debug_dir; 610 611 return status; 612 } 613 614 /************************************************************************** 615 * @ingroup SalCtrl 616 * @description 617 * This function calls the start function on all the service instances. 618 * 619 * @context 620 * This function is called from the SalCtrl_ServiceEventStart function. 621 * 622 * @assumptions 623 * None 624 * @sideEffects 625 * None 626 * @reentrant 627 * No 628 * @threadSafe 629 * Yes 630 * 631 * @param[in] device An icp_accel_dev_t* type 632 * @param[in] services A pointer to the container of services 633 * 634 **************************************************************************/ 635 static CpaStatus 636 SalCtrl_ServiceStart(icp_accel_dev_t *device, sal_list_t *services) 637 { 638 CpaStatus status = CPA_STATUS_SUCCESS; 639 640 /* Call Start function for each service instance */ 641 SAL_FOR_EACH(services, sal_service_t, device, start, status); 642 if (CPA_STATUS_SUCCESS != status) { 643 QAT_UTILS_LOG("Failed to start all instances.\n"); 644 /* stop all instances started before error */ 645 SAL_FOR_EACH_STATE(services, 646 sal_service_t, 647 device, 648 stop, 649 SAL_SERVICE_STATE_RUNNING); 650 return status; 651 } 652 653 if (icp_adf_is_dev_in_reset(device)) { 654 sal_list_t *curr_element = services; 655 sal_service_t *service = NULL; 656 while (NULL != curr_element) { 657 service = 658 (sal_service_t *)SalList_getObject(curr_element); 659 if (service->notification_cb) { 660 service->notification_cb( 661 service, 662 service->cb_tag, 663 CPA_INSTANCE_EVENT_RESTARTED); 664 } 665 curr_element = SalList_next(curr_element); 666 } 667 } 668 669 return status; 670 } 671 672 /**************************************************************************** 673 * @ingroup SalCtrl 674 * @description 675 * This function calls the stop function on all the 676 * service instances. 677 * 678 * @context 679 * This function is called from the SalCtrl_ServiceEventStop function. 680 * 681 * @assumptions 682 * None 683 * @sideEffects 684 * None 685 * @reentrant 686 * No 687 * @threadSafe 688 * Yes 689 * 690 * @param[in] device An icp_accel_dev_t* type 691 * @param[in] services A pointer to the container of services 692 * 693 *************************************************************************/ 694 static CpaStatus 695 SalCtrl_ServiceStop(icp_accel_dev_t *device, sal_list_t *services) 696 { 697 CpaStatus status = CPA_STATUS_SUCCESS; 698 699 /* Calling restarting functions */ 700 if (icp_adf_is_dev_in_reset(device)) { 701 sal_list_t *curr_element = services; 702 sal_service_t *service = NULL; 703 while (NULL != curr_element) { 704 service = 705 (sal_service_t *)SalList_getObject(curr_element); 706 if (service->notification_cb) { 707 service->notification_cb( 708 service, 709 service->cb_tag, 710 CPA_INSTANCE_EVENT_RESTARTING); 711 } 712 curr_element = SalList_next(curr_element); 713 } 714 } 715 716 /* Call Stop function for each service instance */ 717 SAL_FOR_EACH(services, sal_service_t, device, stop, status); 718 719 return status; 720 } 721 722 static CpaStatus 723 SalCtrl_ServiceError(icp_accel_dev_t *device, sal_list_t *services) 724 { 725 CpaStatus status = CPA_STATUS_SUCCESS; 726 727 /* Calling error handling functions */ 728 sal_list_t *curr_element = services; 729 sal_service_t *service = NULL; 730 while (NULL != curr_element) { 731 service = (sal_service_t *)SalList_getObject(curr_element); 732 if (service->notification_cb) { 733 service->notification_cb( 734 service, 735 service->cb_tag, 736 CPA_INSTANCE_EVENT_FATAL_ERROR); 737 } 738 curr_element = SalList_next(curr_element); 739 } 740 741 return status; 742 } 743 744 /* 745 * @ingroup SalCtrl 746 * @description 747 * This function is used to print hardware and software versions in proc 748 * filesystem entry via ADF Debug interface 749 * 750 * @context 751 * This functions is called from proc filesystem interface 752 * 753 * @assumptions 754 * None 755 * @sideEffects 756 * None 757 * @reentrant 758 * No 759 * @threadSafe 760 * Yes 761 * 762 * @param[in] private_data A pointer to a private data passed to the 763 * function while adding a debug file. 764 * @param[out] data Pointer to a buffer where version information 765 * needs to be printed to. 766 * @param[in] size Size of a buffer pointed by data. 767 * @param[in] offset Offset in a debug file 768 * 769 * @retval 0 This function always returns 0 770 */ 771 static int 772 SalCtrl_VersionDebug(void *private_data, char *data, int size, int offset) 773 { 774 CpaStatus status = CPA_STATUS_SUCCESS; 775 Cpa32U len = 0; 776 icp_accel_dev_t *device = (icp_accel_dev_t *)private_data; 777 char param_value[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 }; 778 779 len += snprintf( 780 data + len, 781 size - len, 782 SEPARATOR BORDER 783 " Hardware and Software versions for device %d " BORDER 784 "\n" SEPARATOR, 785 device->accelId); 786 787 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 788 status = icp_adf_cfgGetParamValue(device, 789 LAC_CFG_SECTION_GENERAL, 790 ICP_CFG_HW_REV_ID_KEY, 791 param_value); 792 LAC_CHECK_STATUS(status); 793 794 len += snprintf(data + len, 795 size - len, 796 " Hardware Version: %s %s \n", 797 param_value, 798 get_sku_info(device->sku)); 799 800 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 801 status = icp_adf_cfgGetParamValue(device, 802 LAC_CFG_SECTION_GENERAL, 803 ICP_CFG_UOF_VER_KEY, 804 param_value); 805 LAC_CHECK_STATUS(status); 806 807 len += snprintf(data + len, 808 size - len, 809 " Firmware Version: %s \n", 810 param_value); 811 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 812 status = icp_adf_cfgGetParamValue(device, 813 LAC_CFG_SECTION_GENERAL, 814 ICP_CFG_MMP_VER_KEY, 815 param_value); 816 LAC_CHECK_STATUS(status); 817 818 len += snprintf(data + len, 819 size - len, 820 " MMP Version: %s \n", 821 param_value); 822 len += snprintf(data + len, 823 size - len, 824 " Driver Version: %d.%d.%d \n", 825 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER, 826 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER, 827 SAL_INFO2_DRIVER_SW_VERSION_PATCH_NUMBER); 828 829 memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES); 830 status = icp_adf_cfgGetParamValue(device, 831 LAC_CFG_SECTION_GENERAL, 832 ICP_CFG_LO_COMPATIBLE_DRV_KEY, 833 param_value); 834 LAC_CHECK_STATUS(status); 835 836 len += snprintf(data + len, 837 size - len, 838 " Lowest Compatible Driver: %s \n", 839 param_value); 840 841 len += snprintf(data + len, 842 size - len, 843 " QuickAssist API CY Version: %d.%d \n", 844 CPA_CY_API_VERSION_NUM_MAJOR, 845 CPA_CY_API_VERSION_NUM_MINOR); 846 len += snprintf(data + len, 847 size - len, 848 " QuickAssist API DC Version: %d.%d \n", 849 CPA_DC_API_VERSION_NUM_MAJOR, 850 CPA_DC_API_VERSION_NUM_MINOR); 851 852 len += snprintf(data + len, size - len, SEPARATOR); 853 return 0; 854 } 855 856 /************************************************************************** 857 * @ingroup SalCtrl 858 * @description 859 * This function calls the shutdown function on all the service 860 * instances. It also frees all service instance memory 861 * allocated at Init. 862 * 863 * @context 864 * This function is called from the SalCtrl_ServiceEventHandler function. 865 * 866 * @assumptions 867 * None 868 * @sideEffects 869 * None 870 * @reentrant 871 * No 872 * @threadSafe 873 * Yes 874 * 875 * @param[in] device An icp_accel_dev_t* type 876 * @param[in] enabled_services Services enabled by user 877 * 878 ****************************************************************************/ 879 static CpaStatus 880 SalCtrl_ServiceEventShutdown(icp_accel_dev_t *device, Cpa32U enabled_services) 881 { 882 CpaStatus status = CPA_STATUS_SUCCESS; 883 CpaStatus ret_status = CPA_STATUS_SUCCESS; 884 sal_t *service_container = (sal_t *)device->pSalHandle; 885 886 if (NULL == service_container) { 887 QAT_UTILS_LOG("Private data is NULL\n"); 888 return CPA_STATUS_FATAL; 889 } 890 891 if (SalCtrl_IsServiceEnabled(enabled_services, 892 SAL_SERVICE_TYPE_CRYPTO)) { 893 status = 894 SalCtrl_ServiceShutdown(device, 895 &service_container->crypto_services, 896 &service_container->cy_dir, 897 SAL_SERVICE_TYPE_CRYPTO); 898 if (CPA_STATUS_SUCCESS != status) { 899 ret_status = status; 900 } 901 } 902 903 if (SalCtrl_IsServiceEnabled(enabled_services, 904 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 905 status = 906 SalCtrl_ServiceShutdown(device, 907 &service_container->asym_services, 908 &service_container->asym_dir, 909 SAL_SERVICE_TYPE_CRYPTO_ASYM); 910 if (CPA_STATUS_SUCCESS != status) { 911 ret_status = status; 912 } 913 } 914 915 if (SalCtrl_IsServiceEnabled(enabled_services, 916 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 917 status = 918 SalCtrl_ServiceShutdown(device, 919 &service_container->sym_services, 920 &service_container->sym_dir, 921 SAL_SERVICE_TYPE_CRYPTO_SYM); 922 if (CPA_STATUS_SUCCESS != status) { 923 ret_status = status; 924 } 925 } 926 927 if (SalCtrl_IsServiceEnabled(enabled_services, 928 SAL_SERVICE_TYPE_COMPRESSION)) { 929 status = SalCtrl_ServiceShutdown( 930 device, 931 &service_container->compression_services, 932 &service_container->dc_dir, 933 SAL_SERVICE_TYPE_COMPRESSION); 934 if (CPA_STATUS_SUCCESS != status) { 935 ret_status = status; 936 } 937 } 938 939 if (service_container->ver_file) { 940 icp_adf_debugRemoveFile(service_container->ver_file); 941 LAC_OS_FREE(service_container->ver_file); 942 service_container->ver_file = NULL; 943 } 944 945 if (!icp_adf_is_dev_in_reset(device)) { 946 /* Free container also */ 947 free(service_container, M_QAT); 948 device->pSalHandle = NULL; 949 } 950 951 return ret_status; 952 } 953 954 /************************************************************************* 955 * @ingroup SalCtrl 956 * @description 957 * This function is used to initialize the service instances. 958 * It first checks (via ADF query) which services are enabled in the 959 * system and the number of each services. 960 * It then invokes the init function on them which creates the 961 * instances and allocates memory for them. 962 * 963 * @context 964 * This function is called from the SalCtrl_ServiceEventHandler function. 965 * 966 * @assumptions 967 * None 968 * @sideEffects 969 * None 970 * @reentrant 971 * No 972 * @threadSafe 973 * Yes 974 * 975 * @param[in] device An icp_accel_dev_t* type 976 * @param[in] enabled_services Services enabled by user 977 * 978 *************************************************************************/ 979 static CpaStatus 980 SalCtrl_ServiceEventInit(icp_accel_dev_t *device, Cpa32U enabled_services) 981 { 982 sal_t *service_container = NULL; 983 CpaStatus status = CPA_STATUS_SUCCESS; 984 sal_list_t *tail_list = NULL; 985 Cpa32U instance_count = 0; 986 987 status = SalCtrl_GetSupportedServices(device, enabled_services); 988 if (CPA_STATUS_SUCCESS != status) { 989 QAT_UTILS_LOG("Failed to get supported services.\n"); 990 return status; 991 } 992 993 if (!icp_adf_is_dev_in_reset(device)) { 994 service_container = malloc(sizeof(sal_t), M_QAT, M_WAITOK); 995 device->pSalHandle = service_container; 996 service_container->asym_services = NULL; 997 service_container->sym_services = NULL; 998 service_container->crypto_services = NULL; 999 service_container->compression_services = NULL; 1000 } else { 1001 service_container = device->pSalHandle; 1002 } 1003 service_container->asym_dir = NULL; 1004 service_container->sym_dir = NULL; 1005 service_container->cy_dir = NULL; 1006 service_container->dc_dir = NULL; 1007 service_container->ver_file = NULL; 1008 1009 service_container->ver_file = LAC_OS_MALLOC(sizeof(debug_file_info_t)); 1010 if (NULL == service_container->ver_file) { 1011 free(service_container, M_QAT); 1012 return CPA_STATUS_RESOURCE; 1013 } 1014 1015 memset(service_container->ver_file, 0, sizeof(debug_file_info_t)); 1016 service_container->ver_file->name = ver_file_name; 1017 service_container->ver_file->seq_read = SalCtrl_VersionDebug; 1018 service_container->ver_file->private_data = device; 1019 service_container->ver_file->parent = NULL; 1020 1021 status = icp_adf_debugAddFile(device, service_container->ver_file); 1022 if (CPA_STATUS_SUCCESS != status) { 1023 LAC_OS_FREE(service_container->ver_file); 1024 free(service_container, M_QAT); 1025 return status; 1026 } 1027 1028 if (SalCtrl_IsServiceEnabled(enabled_services, 1029 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 1030 status = SalCtrl_GetInstanceCount(device, 1031 "NumberCyInstances", 1032 &instance_count); 1033 if (CPA_STATUS_SUCCESS != status) { 1034 instance_count = 0; 1035 } 1036 status = SalCtrl_ServiceInit(device, 1037 &service_container->asym_services, 1038 &service_container->asym_dir, 1039 asym_dir_name, 1040 tail_list, 1041 instance_count, 1042 SAL_SERVICE_TYPE_CRYPTO_ASYM); 1043 if (CPA_STATUS_SUCCESS != status) { 1044 goto err_init; 1045 } 1046 } 1047 1048 if (SalCtrl_IsServiceEnabled(enabled_services, 1049 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 1050 status = SalCtrl_GetInstanceCount(device, 1051 "NumberCyInstances", 1052 &instance_count); 1053 if (CPA_STATUS_SUCCESS != status) { 1054 instance_count = 0; 1055 } 1056 status = SalCtrl_ServiceInit(device, 1057 &service_container->sym_services, 1058 &service_container->sym_dir, 1059 sym_dir_name, 1060 tail_list, 1061 instance_count, 1062 SAL_SERVICE_TYPE_CRYPTO_SYM); 1063 if (CPA_STATUS_SUCCESS != status) { 1064 goto err_init; 1065 } 1066 } 1067 1068 if (SalCtrl_IsServiceEnabled(enabled_services, 1069 SAL_SERVICE_TYPE_CRYPTO)) { 1070 status = SalCtrl_GetInstanceCount(device, 1071 "NumberCyInstances", 1072 &instance_count); 1073 if (CPA_STATUS_SUCCESS != status) { 1074 instance_count = 0; 1075 } 1076 status = 1077 SalCtrl_ServiceInit(device, 1078 &service_container->crypto_services, 1079 &service_container->cy_dir, 1080 cy_dir_name, 1081 tail_list, 1082 instance_count, 1083 SAL_SERVICE_TYPE_CRYPTO); 1084 if (CPA_STATUS_SUCCESS != status) { 1085 goto err_init; 1086 } 1087 } 1088 if (SalCtrl_IsServiceEnabled(enabled_services, 1089 SAL_SERVICE_TYPE_COMPRESSION)) { 1090 status = SalCtrl_GetInstanceCount(device, 1091 "NumberDcInstances", 1092 &instance_count); 1093 if (CPA_STATUS_SUCCESS != status) { 1094 instance_count = 0; 1095 } 1096 status = SalCtrl_ServiceInit( 1097 device, 1098 &service_container->compression_services, 1099 &service_container->dc_dir, 1100 dc_dir_name, 1101 tail_list, 1102 instance_count, 1103 SAL_SERVICE_TYPE_COMPRESSION); 1104 if (CPA_STATUS_SUCCESS != status) { 1105 goto err_init; 1106 } 1107 } 1108 1109 return status; 1110 1111 err_init: 1112 SalCtrl_ServiceEventShutdown(device, enabled_services); 1113 return status; 1114 } 1115 1116 /**************************************************************************** 1117 * @ingroup SalCtrl 1118 * @description 1119 * This function calls the stop function on all the service instances. 1120 * 1121 * @context 1122 * This function is called from the SalCtrl_ServiceEventHandler function. 1123 * 1124 * @assumptions 1125 * None 1126 * @sideEffects 1127 * None 1128 * @reentrant 1129 * No 1130 * @threadSafe 1131 * Yes 1132 * 1133 * @param[in] device An icp_accel_dev_t* type 1134 * @param[in] enabled_services Enabled services by user 1135 * 1136 *************************************************************************/ 1137 static CpaStatus 1138 SalCtrl_ServiceEventStop(icp_accel_dev_t *device, Cpa32U enabled_services) 1139 { 1140 CpaStatus status = CPA_STATUS_SUCCESS; 1141 CpaStatus ret_status = CPA_STATUS_SUCCESS; 1142 sal_t *service_container = device->pSalHandle; 1143 1144 if (service_container == NULL) { 1145 QAT_UTILS_LOG("Private data is NULL.\n"); 1146 return CPA_STATUS_FATAL; 1147 } 1148 1149 if (SalCtrl_IsServiceEnabled(enabled_services, 1150 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 1151 status = SalCtrl_ServiceStop(device, 1152 service_container->asym_services); 1153 if (CPA_STATUS_SUCCESS != status) { 1154 ret_status = status; 1155 } 1156 } 1157 1158 if (SalCtrl_IsServiceEnabled(enabled_services, 1159 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 1160 status = SalCtrl_ServiceStop(device, 1161 service_container->sym_services); 1162 if (CPA_STATUS_SUCCESS != status) { 1163 ret_status = status; 1164 } 1165 } 1166 1167 if (SalCtrl_IsServiceEnabled(enabled_services, 1168 SAL_SERVICE_TYPE_CRYPTO)) { 1169 status = 1170 SalCtrl_ServiceStop(device, 1171 service_container->crypto_services); 1172 if (CPA_STATUS_SUCCESS != status) { 1173 ret_status = status; 1174 } 1175 } 1176 1177 if (SalCtrl_IsServiceEnabled(enabled_services, 1178 SAL_SERVICE_TYPE_COMPRESSION)) { 1179 status = SalCtrl_ServiceStop( 1180 device, service_container->compression_services); 1181 if (CPA_STATUS_SUCCESS != status) { 1182 ret_status = status; 1183 } 1184 } 1185 1186 return ret_status; 1187 } 1188 1189 /************************************************************************** 1190 * @ingroup SalCtrl 1191 * @description 1192 * This function calls the error function on all the service instances. 1193 * 1194 * @context 1195 * This function is called from the SalCtrl_ServiceEventHandler function. 1196 * 1197 * @assumptions 1198 * None 1199 * @sideEffects 1200 * None 1201 * @reentrant 1202 * No 1203 * @threadSafe 1204 * Yes 1205 * 1206 * @param[in] device An icp_accel_dev_t* type 1207 * @param[in] enabled_services Enabled services by user 1208 * 1209 **************************************************************************/ 1210 static CpaStatus 1211 SalCtrl_ServiceEventError(icp_accel_dev_t *device, Cpa32U enabled_services) 1212 { 1213 CpaStatus status = CPA_STATUS_SUCCESS; 1214 CpaStatus ret_status = CPA_STATUS_SUCCESS; 1215 sal_t *service_container = device->pSalHandle; 1216 1217 if (service_container == NULL) { 1218 QAT_UTILS_LOG("Private data is NULL\n"); 1219 return CPA_STATUS_FATAL; 1220 } 1221 if (SalCtrl_IsServiceEnabled(enabled_services, 1222 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 1223 status = SalCtrl_ServiceError(device, 1224 service_container->asym_services); 1225 if (CPA_STATUS_SUCCESS != status) { 1226 ret_status = status; 1227 } 1228 } 1229 1230 if (SalCtrl_IsServiceEnabled(enabled_services, 1231 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 1232 status = SalCtrl_ServiceError(device, 1233 service_container->sym_services); 1234 if (CPA_STATUS_SUCCESS != status) { 1235 ret_status = status; 1236 } 1237 } 1238 1239 if (SalCtrl_IsServiceEnabled(enabled_services, 1240 SAL_SERVICE_TYPE_CRYPTO)) { 1241 status = 1242 SalCtrl_ServiceError(device, 1243 service_container->crypto_services); 1244 if (CPA_STATUS_SUCCESS != status) { 1245 ret_status = status; 1246 } 1247 } 1248 1249 if (SalCtrl_IsServiceEnabled(enabled_services, 1250 SAL_SERVICE_TYPE_COMPRESSION)) { 1251 status = SalCtrl_ServiceError( 1252 device, service_container->compression_services); 1253 if (CPA_STATUS_SUCCESS != status) { 1254 ret_status = status; 1255 } 1256 } 1257 1258 return ret_status; 1259 } 1260 1261 /************************************************************************** 1262 * @ingroup SalCtrl 1263 * @description 1264 * This function calls the start function on all the service instances. 1265 * 1266 * @context 1267 * This function is called from the SalCtrl_ServiceEventHandler function. 1268 * 1269 * @assumptions 1270 * None 1271 * @sideEffects 1272 * None 1273 * @reentrant 1274 * No 1275 * @threadSafe 1276 * Yes 1277 * 1278 * @param[in] device An icp_accel_dev_t* type 1279 * @param[in] enabled_services Enabled services by user 1280 * 1281 **************************************************************************/ 1282 static CpaStatus 1283 SalCtrl_ServiceEventStart(icp_accel_dev_t *device, Cpa32U enabled_services) 1284 { 1285 CpaStatus status = CPA_STATUS_SUCCESS; 1286 sal_t *service_container = device->pSalHandle; 1287 1288 if (service_container == NULL) { 1289 QAT_UTILS_LOG("Private data is NULL.\n"); 1290 return CPA_STATUS_FATAL; 1291 } 1292 1293 if (SalCtrl_IsServiceEnabled(enabled_services, 1294 SAL_SERVICE_TYPE_CRYPTO_ASYM)) { 1295 status = SalCtrl_ServiceStart(device, 1296 service_container->asym_services); 1297 if (CPA_STATUS_SUCCESS != status) { 1298 goto err_start; 1299 } 1300 } 1301 1302 if (SalCtrl_IsServiceEnabled(enabled_services, 1303 SAL_SERVICE_TYPE_CRYPTO_SYM)) { 1304 status = SalCtrl_ServiceStart(device, 1305 service_container->sym_services); 1306 if (CPA_STATUS_SUCCESS != status) { 1307 goto err_start; 1308 } 1309 } 1310 1311 if (SalCtrl_IsServiceEnabled(enabled_services, 1312 SAL_SERVICE_TYPE_CRYPTO)) { 1313 status = 1314 SalCtrl_ServiceStart(device, 1315 service_container->crypto_services); 1316 if (CPA_STATUS_SUCCESS != status) { 1317 goto err_start; 1318 } 1319 } 1320 1321 if (SalCtrl_IsServiceEnabled(enabled_services, 1322 SAL_SERVICE_TYPE_COMPRESSION)) { 1323 status = SalCtrl_ServiceStart( 1324 device, service_container->compression_services); 1325 if (CPA_STATUS_SUCCESS != status) { 1326 goto err_start; 1327 } 1328 } 1329 1330 return status; 1331 err_start: 1332 SalCtrl_ServiceEventStop(device, enabled_services); 1333 return status; 1334 } 1335 1336 /************************************************************************* 1337 * @ingroup SalCtrl 1338 * @description 1339 * This function is the events handler registered with ADF 1340 * for the QA API services (cy, dc) - kernel and user 1341 * 1342 * @context 1343 * This function is called from an ADF context. 1344 * 1345 * @assumptions 1346 * None 1347 * @sideEffects 1348 * None 1349 * @reentrant 1350 * No 1351 * @threadSafe 1352 * Yes 1353 * 1354 * @param[in] device An icp_accel_dev_t* type 1355 * @param[in] event Event from ADF 1356 * @param[in] param Parameter used for back compatibility 1357 * 1358 ***********************************************************************/ 1359 static CpaStatus 1360 SalCtrl_ServiceEventHandler(icp_accel_dev_t *device, 1361 icp_adf_subsystemEvent_t event, 1362 void *param) 1363 { 1364 CpaStatus status = CPA_STATUS_SUCCESS; 1365 CpaStatus stats_status = CPA_STATUS_SUCCESS; 1366 Cpa32U enabled_services = 0; 1367 1368 status = SalCtrl_GetEnabledServices(device, &enabled_services); 1369 if (CPA_STATUS_SUCCESS != status) { 1370 QAT_UTILS_LOG("Failed to get enabled services.\n"); 1371 return status; 1372 } 1373 1374 switch (event) { 1375 case ICP_ADF_EVENT_INIT: { 1376 /* In case there is no QAT SAL needs to call InitStats */ 1377 if (NULL == device->pQatStats) { 1378 status = SalStatistics_InitStatisticsCollection(device); 1379 } 1380 if (CPA_STATUS_SUCCESS != status) { 1381 return status; 1382 } 1383 1384 status = SalCtrl_ServiceEventInit(device, enabled_services); 1385 break; 1386 } 1387 case ICP_ADF_EVENT_START: { 1388 status = SalCtrl_ServiceEventStart(device, enabled_services); 1389 break; 1390 } 1391 case ICP_ADF_EVENT_STOP: { 1392 status = SalCtrl_ServiceEventStop(device, enabled_services); 1393 break; 1394 } 1395 case ICP_ADF_EVENT_SHUTDOWN: { 1396 status = SalCtrl_ServiceEventShutdown(device, enabled_services); 1397 stats_status = SalStatistics_CleanStatisticsCollection(device); 1398 if (CPA_STATUS_SUCCESS != status || 1399 CPA_STATUS_SUCCESS != stats_status) { 1400 return CPA_STATUS_FAIL; 1401 } 1402 break; 1403 } 1404 case ICP_ADF_EVENT_ERROR: { 1405 status = SalCtrl_ServiceEventError(device, enabled_services); 1406 break; 1407 } 1408 default: 1409 status = CPA_STATUS_SUCCESS; 1410 break; 1411 } 1412 return status; 1413 } 1414 1415 CpaStatus 1416 SalCtrl_AdfServicesRegister(void) 1417 { 1418 /* Fill out the global sal_service_reg_handle structure */ 1419 sal_service_reg_handle.subserviceEventHandler = 1420 SalCtrl_ServiceEventHandler; 1421 /* Set subsystem name to globally defined name */ 1422 sal_service_reg_handle.subsystem_name = subsystem_name; 1423 1424 return icp_adf_subsystemRegister(&sal_service_reg_handle); 1425 } 1426 1427 CpaStatus 1428 SalCtrl_AdfServicesUnregister(void) 1429 { 1430 return icp_adf_subsystemUnregister(&sal_service_reg_handle); 1431 } 1432 1433 CpaStatus 1434 SalCtrl_AdfServicesStartedCheck(void) 1435 { 1436 CpaStatus status = CPA_STATUS_SUCCESS; 1437 Cpa32U retry_num = 0; 1438 CpaBoolean state = CPA_FALSE; 1439 1440 do { 1441 state = icp_adf_isSubsystemStarted(&sal_service_reg_handle); 1442 retry_num++; 1443 } while ((CPA_FALSE == state) && (retry_num < MAX_SUBSYSTEM_RETRY)); 1444 1445 if (CPA_FALSE == state) { 1446 QAT_UTILS_LOG("Sal Ctrl failed to start in given time.\n"); 1447 status = CPA_STATUS_FAIL; 1448 } 1449 1450 return status; 1451 } 1452 1453 CpaStatus 1454 validateConcurrRequest(Cpa32U numConcurrRequests) 1455 { 1456 Cpa32U baseReq = SAL_64_CONCURR_REQUESTS; 1457 1458 if (SAL_64_CONCURR_REQUESTS > numConcurrRequests) { 1459 QAT_UTILS_LOG( 1460 "Invalid numConcurrRequests, it is less than min value.\n"); 1461 return CPA_STATUS_FAIL; 1462 } 1463 1464 while (SAL_MAX_CONCURR_REQUESTS >= baseReq) { 1465 if (baseReq != numConcurrRequests) { 1466 baseReq = baseReq << 1; 1467 } else { 1468 break; 1469 } 1470 } 1471 if (SAL_MAX_CONCURR_REQUESTS < baseReq) { 1472 QAT_UTILS_LOG( 1473 "Invalid baseReg, it is greater than max value.\n"); 1474 return CPA_STATUS_FAIL; 1475 } 1476 1477 return CPA_STATUS_SUCCESS; 1478 } 1479