1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2025 Intel Corporation */
3 /**
4 *****************************************************************************
5 * @file sal_compression.c
6 *
7 * @ingroup SalCtrl
8 *
9 * @description
10 * This file contains the sal implementation for compression.
11 *
12 *****************************************************************************/
13
14 /* QAT-API includes */
15 #include "cpa.h"
16 #include "cpa_dc.h"
17
18 /* QAT utils includes */
19 #include "qat_utils.h"
20
21 /* ADF includes */
22 #include "icp_adf_init.h"
23 #include "icp_adf_transport.h"
24 #include "icp_accel_devices.h"
25 #include "icp_adf_cfg.h"
26 #include "icp_adf_accel_mgr.h"
27 #include "icp_adf_poll.h"
28 #include "icp_adf_debug.h"
29 #include "icp_adf_esram.h"
30 #include "icp_qat_hw.h"
31
32 /* SAL includes */
33 #include "lac_mem.h"
34 #include "lac_common.h"
35 #include "lac_mem_pools.h"
36 #include "sal_statistics.h"
37 #include "lac_list.h"
38 #include "icp_sal_poll.h"
39 #include "sal_types_compression.h"
40 #include "dc_session.h"
41 #include "dc_datapath.h"
42 #include "dc_stats.h"
43 #include "lac_sal.h"
44 #include "lac_sal_ctrl.h"
45 #include "sal_string_parse.h"
46 #include "sal_service_state.h"
47 #include "lac_buffer_desc.h"
48 #include "icp_qat_fw_comp.h"
49 #include "icp_qat_hw_20_comp_defs.h"
50 #include "icp_sal_versions.h"
51
52 /* C string null terminator size */
53 #define SAL_NULL_TERM_SIZE 1
54
55 /*
56 * Prints statistics for a compression instance
57 */
58 static int
SalCtrl_CompresionDebug(void * private_data,char * data,int size,int offset)59 SalCtrl_CompresionDebug(void *private_data, char *data, int size, int offset)
60 {
61 sal_compression_service_t *pCompressionService =
62 (sal_compression_service_t *)private_data;
63 CpaStatus status = CPA_STATUS_SUCCESS;
64 CpaDcStats dcStats = { 0 };
65 Cpa32S len = 0;
66
67 status = cpaDcGetStats(pCompressionService, &dcStats);
68 if (status != CPA_STATUS_SUCCESS) {
69 QAT_UTILS_LOG("cpaDcGetStats returned error.\n");
70 return (-1);
71 }
72
73 /* Engine Info */
74 if (NULL != pCompressionService->debug_file) {
75 len += snprintf(data + len,
76 size - len,
77 SEPARATOR BORDER
78 " Statistics for Instance %24s | \n" SEPARATOR,
79 pCompressionService->debug_file->name);
80 }
81
82 /* Perform Info */
83 len += snprintf(data + len,
84 size - len,
85 BORDER " DC comp Requests: %16llu " BORDER
86 "\n" BORDER
87 " DC comp Request Errors: %16llu " BORDER
88 "\n" BORDER
89 " DC comp Completed: %16llu " BORDER
90 "\n" BORDER
91 " DC comp Completed Errors: %16llu " BORDER
92 "\n" SEPARATOR,
93 (long long unsigned int)dcStats.numCompRequests,
94 (long long unsigned int)dcStats.numCompRequestsErrors,
95 (long long unsigned int)dcStats.numCompCompleted,
96 (long long unsigned int)dcStats.numCompCompletedErrors);
97
98 /* Perform Info */
99 len += snprintf(
100 data + len,
101 size - len,
102 BORDER " DC decomp Requests: %16llu " BORDER "\n" BORDER
103 " DC decomp Request Errors: %16llu " BORDER "\n" BORDER
104 " DC decomp Completed: %16llu " BORDER "\n" BORDER
105 " DC decomp Completed Errors: %16llu " BORDER
106 "\n" SEPARATOR,
107 (long long unsigned int)dcStats.numDecompRequests,
108 (long long unsigned int)dcStats.numDecompRequestsErrors,
109 (long long unsigned int)dcStats.numDecompCompleted,
110 (long long unsigned int)dcStats.numDecompCompletedErrors);
111 return 0;
112 }
113
114 /* Initialise device specific information needed by compression service */
115 static CpaStatus
SalCtrl_CompressionInit_CompData(icp_accel_dev_t * device,sal_compression_service_t * pCompService)116 SalCtrl_CompressionInit_CompData(icp_accel_dev_t *device,
117 sal_compression_service_t *pCompService)
118 {
119 int level = 0;
120 pCompService->comp_device_data.asbEnableSupport = CPA_FALSE;
121 pCompService->comp_device_data.uniqueCompressionLevels[0] = CPA_FALSE;
122
123 switch (device->deviceType) {
124 case DEVICE_DH895XCC:
125 case DEVICE_DH895XCCVF:
126 pCompService->generic_service_info.integrityCrcCheck =
127 CPA_FALSE;
128 pCompService->numInterBuffs =
129 DC_QAT_MAX_NUM_INTER_BUFFERS_6COMP_SLICES;
130 pCompService->comp_device_data.minOutputBuffSize =
131 DC_DEST_BUFFER_STA_MIN_SIZE;
132 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
133 pCompService->comp_device_data.oddByteDecompInterim = CPA_FALSE;
134 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
135 pCompService->comp_device_data.useDevRam =
136 ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
137 pCompService->comp_device_data.enableDmm =
138 ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_DISABLED;
139
140 pCompService->comp_device_data.inflateContextSize =
141 DC_INFLATE_CONTEXT_SIZE;
142 pCompService->comp_device_data.highestHwCompressionDepth =
143 ICP_QAT_HW_COMPRESSION_DEPTH_16;
144
145 pCompService->comp_device_data.windowSizeMask =
146 (1 << DC_8K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
147 pCompService->comp_device_data.cnvnrSupported = CPA_FALSE;
148 for (level = CPA_DC_L1; level <= CPA_DC_L12; level++) {
149 switch (level) {
150 case CPA_DC_L1:
151 case CPA_DC_L2:
152 case CPA_DC_L3:
153 case CPA_DC_L4:
154 pCompService->comp_device_data
155 .uniqueCompressionLevels[level] = CPA_TRUE;
156 break;
157 default:
158 pCompService->comp_device_data
159 .uniqueCompressionLevels[level] = CPA_FALSE;
160 break;
161 }
162 }
163 pCompService->comp_device_data.numCompressionLevels =
164 DC_NUM_COMPRESSION_LEVELS;
165 break;
166 case DEVICE_C3XXX:
167 case DEVICE_C3XXXVF:
168 case DEVICE_200XX:
169 case DEVICE_200XXVF:
170 pCompService->generic_service_info.integrityCrcCheck =
171 CPA_FALSE;
172 pCompService->numInterBuffs =
173 DC_QAT_MAX_NUM_INTER_BUFFERS_6COMP_SLICES;
174 pCompService->comp_device_data.oddByteDecompNobFinal =
175 CPA_FALSE;
176 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
177 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
178 pCompService->comp_device_data.useDevRam =
179 ICP_QAT_FW_COMP_DISABLE_SECURE_RAM_USED_AS_INTMD_BUF;
180 pCompService->comp_device_data.inflateContextSize =
181 DC_INFLATE_EH_CONTEXT_SIZE;
182 pCompService->comp_device_data.highestHwCompressionDepth =
183 ICP_QAT_HW_COMPRESSION_DEPTH_16;
184 pCompService->comp_device_data.windowSizeMask =
185 (1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
186 pCompService->comp_device_data.minOutputBuffSize =
187 DC_DEST_BUFFER_STA_MIN_SIZE;
188 pCompService->comp_device_data.enableDmm =
189 ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
190
191 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
192
193 for (level = CPA_DC_L1; level <= CPA_DC_L12; level++) {
194 switch (level) {
195 case CPA_DC_L1:
196 case CPA_DC_L2:
197 case CPA_DC_L3:
198 case CPA_DC_L4:
199 pCompService->comp_device_data
200 .uniqueCompressionLevels[level] = CPA_TRUE;
201 break;
202 default:
203 pCompService->comp_device_data
204 .uniqueCompressionLevels[level] = CPA_FALSE;
205 break;
206 }
207 }
208 pCompService->comp_device_data.numCompressionLevels =
209 DC_NUM_COMPRESSION_LEVELS;
210 break;
211 case DEVICE_C62X:
212 case DEVICE_C62XVF:
213 pCompService->generic_service_info.integrityCrcCheck =
214 CPA_FALSE;
215 pCompService->numInterBuffs =
216 DC_QAT_MAX_NUM_INTER_BUFFERS_10COMP_SLICES;
217 pCompService->comp_device_data.oddByteDecompNobFinal =
218 CPA_FALSE;
219 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
220 pCompService->comp_device_data.translatorOverflow = CPA_FALSE;
221 pCompService->comp_device_data.useDevRam =
222 ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
223 pCompService->comp_device_data.inflateContextSize =
224 DC_INFLATE_EH_CONTEXT_SIZE;
225 pCompService->comp_device_data.highestHwCompressionDepth =
226 ICP_QAT_HW_COMPRESSION_DEPTH_16;
227 pCompService->comp_device_data.windowSizeMask =
228 (1 << DC_4K_WINDOW_SIZE | 1 << DC_8K_WINDOW_SIZE |
229 1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
230 pCompService->comp_device_data.minOutputBuffSize =
231 DC_DEST_BUFFER_STA_MIN_SIZE;
232 pCompService->comp_device_data.minOutputBuffSizeDynamic =
233 pCompService->comp_device_data.minOutputBuffSize;
234 pCompService->comp_device_data.enableDmm =
235 ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
236 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
237
238 for (level = CPA_DC_L1; level <= CPA_DC_L12; level++) {
239 switch (level) {
240 case CPA_DC_L1:
241 case CPA_DC_L2:
242 case CPA_DC_L3:
243 case CPA_DC_L4:
244 pCompService->comp_device_data
245 .uniqueCompressionLevels[level] = CPA_TRUE;
246 break;
247 default:
248 pCompService->comp_device_data
249 .uniqueCompressionLevels[level] = CPA_FALSE;
250 break;
251 }
252 }
253 pCompService->comp_device_data.numCompressionLevels =
254 DC_NUM_COMPRESSION_LEVELS;
255 break;
256 case DEVICE_C4XXX:
257 case DEVICE_C4XXXVF:
258 pCompService->generic_service_info.integrityCrcCheck = CPA_TRUE;
259 pCompService->numInterBuffs =
260 DC_QAT_MAX_NUM_INTER_BUFFERS_24COMP_SLICES;
261 pCompService->comp_device_data.minOutputBuffSize =
262 DC_DEST_BUFFER_MIN_SIZE;
263 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
264 pCompService->comp_device_data.oddByteDecompInterim = CPA_TRUE;
265 pCompService->comp_device_data.translatorOverflow = CPA_TRUE;
266 if (pCompService->generic_service_info.capabilitiesMask &
267 ICP_ACCEL_CAPABILITIES_INLINE) {
268 pCompService->comp_device_data.useDevRam =
269 ICP_QAT_FW_COMP_DISABLE_SECURE_RAM_USED_AS_INTMD_BUF;
270 } else {
271 pCompService->comp_device_data.useDevRam =
272 ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
273 }
274 pCompService->comp_device_data.enableDmm =
275 ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
276 pCompService->comp_device_data.inflateContextSize =
277 DC_INFLATE_EH_CONTEXT_SIZE;
278 pCompService->comp_device_data.highestHwCompressionDepth =
279 ICP_QAT_HW_COMPRESSION_DEPTH_128;
280 pCompService->comp_device_data.windowSizeMask =
281 (1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
282 pCompService->comp_device_data.cnvnrSupported = CPA_TRUE;
283
284 for (level = CPA_DC_L1; level <= CPA_DC_L12; level++) {
285 switch (level) {
286 case CPA_DC_L1:
287 case CPA_DC_L2:
288 case CPA_DC_L3:
289 case CPA_DC_L4:
290 case CPA_DC_L5:
291 pCompService->comp_device_data
292 .uniqueCompressionLevels[level] = CPA_TRUE;
293 break;
294 default:
295 pCompService->comp_device_data
296 .uniqueCompressionLevels[level] = CPA_FALSE;
297 break;
298 }
299 }
300 pCompService->comp_device_data.numCompressionLevels =
301 DC_NUM_COMPRESSION_LEVELS;
302 break;
303 case DEVICE_4XXX:
304 case DEVICE_4XXXVF:
305 pCompService->generic_service_info.integrityCrcCheck = CPA_TRUE;
306 pCompService->numInterBuffs = 0;
307 pCompService->comp_device_data.minOutputBuffSize =
308 DC_DEST_BUFFER_STA_MIN_SIZE_GEN4;
309 pCompService->comp_device_data.minOutputBuffSizeDynamic =
310 DC_DEST_BUFFER_DYN_MIN_SIZE_GEN4;
311 pCompService->comp_device_data.oddByteDecompNobFinal = CPA_TRUE;
312 pCompService->comp_device_data.oddByteDecompInterim = CPA_FALSE;
313 pCompService->comp_device_data.translatorOverflow = CPA_TRUE;
314 pCompService->comp_device_data.useDevRam =
315 ICP_QAT_FW_COMP_ENABLE_SECURE_RAM_USED_AS_INTMD_BUF;
316 pCompService->comp_device_data.enableDmm =
317 ICP_QAT_HW_COMPRESSION_DELAYED_MATCH_ENABLED;
318
319 pCompService->comp_device_data.inflateContextSize =
320 DC_INFLATE_CONTEXT_SIZE;
321 pCompService->comp_device_data.highestHwCompressionDepth =
322 ICP_QAT_HW_COMP_20_SEARCH_DEPTH_LEVEL_9;
323 pCompService->comp_device_data.windowSizeMask =
324 (1 << DC_4K_WINDOW_SIZE | 1 << DC_8K_WINDOW_SIZE |
325 1 << DC_16K_WINDOW_SIZE | 1 << DC_32K_WINDOW_SIZE);
326 for (level = CPA_DC_L1; level <= CPA_DC_L12; level++) {
327 switch (level) {
328 case CPA_DC_L1:
329 case CPA_DC_L6:
330 case CPA_DC_L9:
331 pCompService->comp_device_data
332 .uniqueCompressionLevels[level] = CPA_TRUE;
333 break;
334 default:
335 pCompService->comp_device_data
336 .uniqueCompressionLevels[level] = CPA_FALSE;
337 break;
338 }
339 }
340 pCompService->comp_device_data.numCompressionLevels =
341 DC_NUM_COMPRESSION_LEVELS;
342 break;
343 default:
344 QAT_UTILS_LOG("Unknown device type! - %d.\n",
345 device->deviceType);
346 return CPA_STATUS_FAIL;
347 }
348 return CPA_STATUS_SUCCESS;
349 }
350
351 CpaStatus
SalCtrl_CompressionInit(icp_accel_dev_t * device,sal_service_t * service)352 SalCtrl_CompressionInit(icp_accel_dev_t *device, sal_service_t *service)
353 {
354 CpaStatus status = CPA_STATUS_SUCCESS;
355 Cpa32U numCompConcurrentReq = 0;
356 Cpa32U request_ring_id = 0;
357 Cpa32U response_ring_id = 0;
358
359 char adfGetParam[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
360 char compMemPool[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
361 char temp_string[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
362 char temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
363 char *instance_name = NULL;
364 sal_statistics_collection_t *pStatsCollection =
365 (sal_statistics_collection_t *)device->pQatStats;
366 icp_resp_deliv_method rx_resp_type = ICP_RESP_TYPE_IRQ;
367 sal_compression_service_t *pCompressionService =
368 (sal_compression_service_t *)service;
369 Cpa32U msgSize = 0;
370 char *section = DYN_SEC;
371
372 SAL_SERVICE_GOOD_FOR_INIT(pCompressionService);
373
374 if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
375 section = icpGetProcessName();
376 }
377
378 if (pStatsCollection == NULL) {
379 return CPA_STATUS_FAIL;
380 }
381
382 /* Get Config Info: Accel Num, bank Num, packageID,
383 coreAffinity, nodeAffinity and response mode
384 */
385
386 pCompressionService->acceleratorNum = 0;
387
388 /* Initialise device specific compression data */
389 SalCtrl_CompressionInit_CompData(device, pCompressionService);
390
391 status = Sal_StringParsing(
392 "Dc",
393 pCompressionService->generic_service_info.instance,
394 "BankNumber",
395 temp_string);
396 LAC_CHECK_STATUS(status);
397 status =
398 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
399 if (CPA_STATUS_SUCCESS != status) {
400 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
401 temp_string);
402 return status;
403 }
404
405 pCompressionService->bankNum =
406 Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
407
408 status = Sal_StringParsing(
409 "Dc",
410 pCompressionService->generic_service_info.instance,
411 "IsPolled",
412 temp_string);
413 LAC_CHECK_STATUS(status);
414 status =
415 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
416 if (CPA_STATUS_SUCCESS != status) {
417 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
418 temp_string);
419 return status;
420 }
421 pCompressionService->isPolled =
422 (Cpa8U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
423
424 /* User instances only support poll and epoll mode */
425 if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
426 QAT_UTILS_LOG(
427 "IsPolled %u is not supported for user instance %s.\n",
428 pCompressionService->isPolled,
429 temp_string);
430 return CPA_STATUS_FAIL;
431 }
432
433 if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
434 rx_resp_type = ICP_RESP_TYPE_POLL;
435 }
436
437 status = icp_adf_cfgGetParamValue(device,
438 LAC_CFG_SECTION_GENERAL,
439 ADF_DEV_PKG_ID,
440 adfGetParam);
441 if (CPA_STATUS_SUCCESS != status) {
442 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
443 ADF_DEV_PKG_ID);
444 return status;
445 }
446 pCompressionService->pkgID =
447 (Cpa16U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
448
449 status = icp_adf_cfgGetParamValue(device,
450 LAC_CFG_SECTION_GENERAL,
451 ADF_DEV_NODE_ID,
452 adfGetParam);
453 if (CPA_STATUS_SUCCESS != status) {
454 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
455 ADF_DEV_NODE_ID);
456 return status;
457 }
458 pCompressionService->nodeAffinity =
459 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
460
461 /* In case of interrupt instance, use the bank affinity set by adf_ctl
462 * Otherwise, use the instance affinity for backwards compatibility */
463 if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
464 /* Next need to read the [AcceleratorX] section of the config
465 * file */
466 status = Sal_StringParsing("Accelerator",
467 pCompressionService->acceleratorNum,
468 "",
469 temp_string2);
470 LAC_CHECK_STATUS(status);
471
472 status = Sal_StringParsing("Bank",
473 pCompressionService->bankNum,
474 "CoreAffinity",
475 temp_string);
476 LAC_CHECK_STATUS(status);
477 } else {
478 strncpy(temp_string2,
479 section,
480 sizeof(temp_string2) - SAL_NULL_TERM_SIZE);
481 temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES -
482 SAL_NULL_TERM_SIZE] = '\0';
483
484 status = Sal_StringParsing(
485 "Dc",
486 pCompressionService->generic_service_info.instance,
487 "CoreAffinity",
488 temp_string);
489 LAC_CHECK_STATUS(status);
490 }
491
492 status = icp_adf_cfgGetParamValue(device,
493 temp_string2,
494 temp_string,
495 adfGetParam);
496 if (CPA_STATUS_SUCCESS != status) {
497 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
498 temp_string);
499 return status;
500 }
501 pCompressionService->coreAffinity =
502 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
503
504 status = Sal_StringParsing(
505 "Dc",
506 pCompressionService->generic_service_info.instance,
507 "NumConcurrentRequests",
508 temp_string);
509 LAC_CHECK_STATUS(status);
510 status =
511 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
512 if (CPA_STATUS_SUCCESS != status) {
513 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
514 temp_string);
515 return status;
516 }
517
518 numCompConcurrentReq =
519 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
520 if (validateConcurrRequest(numCompConcurrentReq)) {
521 QAT_UTILS_LOG(
522 "Invalid NumConcurrentRequests, valid values are: {64, 128, 256, ... 32768, 65536}.\n");
523 return CPA_STATUS_FAIL;
524 }
525
526 /* ADF does not allow us to completely fill the ring for batch requests
527 */
528 pCompressionService->maxNumCompConcurrentReq =
529 (numCompConcurrentReq - SAL_BATCH_SUBMIT_FREE_SPACE);
530
531 /* 1. Create transport handles */
532 status = Sal_StringParsing(
533 "Dc",
534 pCompressionService->generic_service_info.instance,
535 "RingTx",
536 temp_string);
537 LAC_CHECK_STATUS(status);
538
539 msgSize = LAC_QAT_DC_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES;
540 status = icp_adf_transCreateHandle(
541 device,
542 ICP_TRANS_TYPE_ETR,
543 section,
544 pCompressionService->acceleratorNum,
545 pCompressionService->bankNum,
546 temp_string,
547 lac_getRingType(SAL_RING_TYPE_DC),
548 NULL,
549 ICP_RESP_TYPE_NONE,
550 numCompConcurrentReq,
551 msgSize,
552 (icp_comms_trans_handle *)&(
553 pCompressionService->trans_handle_compression_tx));
554 LAC_CHECK_STATUS(status);
555
556 if (icp_adf_transGetRingNum(
557 pCompressionService->trans_handle_compression_tx,
558 &request_ring_id) != CPA_STATUS_SUCCESS) {
559 icp_adf_transReleaseHandle(
560 pCompressionService->trans_handle_compression_tx);
561
562 QAT_UTILS_LOG("Failed to get DC TX ring number.\n");
563 return CPA_STATUS_FAIL;
564 }
565
566 status = Sal_StringParsing(
567 "Dc",
568 pCompressionService->generic_service_info.instance,
569 "RingRx",
570 temp_string);
571 if (CPA_STATUS_SUCCESS != status) {
572 icp_adf_transReleaseHandle(
573 pCompressionService->trans_handle_compression_tx);
574 return status;
575 }
576
577 msgSize = LAC_QAT_DC_RESP_SZ_LW * LAC_LONG_WORD_IN_BYTES;
578 status = icp_adf_transCreateHandle(
579 device,
580 ICP_TRANS_TYPE_ETR,
581 section,
582 pCompressionService->acceleratorNum,
583 pCompressionService->bankNum,
584 temp_string,
585 lac_getRingType(SAL_RING_TYPE_NONE),
586 (icp_trans_callback)dcCompression_ProcessCallback,
587 rx_resp_type,
588 numCompConcurrentReq,
589 msgSize,
590 (icp_comms_trans_handle *)&(
591 pCompressionService->trans_handle_compression_rx));
592 if (CPA_STATUS_SUCCESS != status) {
593 icp_adf_transReleaseHandle(
594 pCompressionService->trans_handle_compression_tx);
595 return status;
596 }
597
598 if (icp_adf_transGetRingNum(
599 pCompressionService->trans_handle_compression_rx,
600 &response_ring_id) != CPA_STATUS_SUCCESS) {
601 icp_adf_transReleaseHandle(
602 pCompressionService->trans_handle_compression_tx);
603
604 icp_adf_transReleaseHandle(
605 pCompressionService->trans_handle_compression_rx);
606
607 QAT_UTILS_LOG("Failed to get DC RX ring number.\n");
608 return CPA_STATUS_FAIL;
609 }
610
611 /* 2. Allocates memory pools */
612
613 /* Valid initialisation value for a pool ID */
614 pCompressionService->compression_mem_pool = LAC_MEM_POOL_INIT_POOL_ID;
615
616 status = Sal_StringParsing(
617 "Comp",
618 pCompressionService->generic_service_info.instance,
619 "_MemPool",
620 compMemPool);
621 if (CPA_STATUS_SUCCESS != status) {
622 icp_adf_transReleaseHandle(
623 pCompressionService->trans_handle_compression_tx);
624
625 icp_adf_transReleaseHandle(
626 pCompressionService->trans_handle_compression_rx);
627
628 return status;
629 }
630
631 status = Lac_MemPoolCreate(&pCompressionService->compression_mem_pool,
632 compMemPool,
633 (numCompConcurrentReq + 1),
634 sizeof(dc_compression_cookie_t),
635 LAC_64BYTE_ALIGNMENT,
636 CPA_FALSE,
637 pCompressionService->nodeAffinity);
638 if (CPA_STATUS_SUCCESS != status) {
639 icp_adf_transReleaseHandle(
640 pCompressionService->trans_handle_compression_tx);
641
642 icp_adf_transReleaseHandle(
643 pCompressionService->trans_handle_compression_rx);
644
645 return status;
646 }
647
648 /* Init compression statistics */
649 status = dcStatsInit(pCompressionService);
650 if (CPA_STATUS_SUCCESS != status) {
651 Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
652
653 icp_adf_transReleaseHandle(
654 pCompressionService->trans_handle_compression_tx);
655
656 icp_adf_transReleaseHandle(
657 pCompressionService->trans_handle_compression_rx);
658
659 return status;
660 }
661 if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
662 /* Get instance name for stats */
663 instance_name = LAC_OS_MALLOC(ADF_CFG_MAX_VAL_LEN_IN_BYTES);
664 if (NULL == instance_name) {
665 Lac_MemPoolDestroy(
666 pCompressionService->compression_mem_pool);
667
668 icp_adf_transReleaseHandle(
669 pCompressionService->trans_handle_compression_tx);
670
671 icp_adf_transReleaseHandle(
672 pCompressionService->trans_handle_compression_rx);
673
674 return CPA_STATUS_RESOURCE;
675 }
676
677 status = Sal_StringParsing(
678 "Dc",
679 pCompressionService->generic_service_info.instance,
680 "Name",
681 temp_string);
682 if (CPA_STATUS_SUCCESS != status) {
683 Lac_MemPoolDestroy(
684 pCompressionService->compression_mem_pool);
685
686 icp_adf_transReleaseHandle(
687 pCompressionService->trans_handle_compression_tx);
688
689 icp_adf_transReleaseHandle(
690 pCompressionService->trans_handle_compression_rx);
691 LAC_OS_FREE(instance_name);
692 return status;
693 }
694 status = icp_adf_cfgGetParamValue(device,
695 section,
696 temp_string,
697 adfGetParam);
698 if (CPA_STATUS_SUCCESS != status) {
699 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
700 temp_string);
701
702 Lac_MemPoolDestroy(
703 pCompressionService->compression_mem_pool);
704
705 icp_adf_transReleaseHandle(
706 pCompressionService->trans_handle_compression_tx);
707
708 icp_adf_transReleaseHandle(
709 pCompressionService->trans_handle_compression_rx);
710 LAC_OS_FREE(instance_name);
711 return status;
712 }
713
714 snprintf(instance_name,
715 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
716 "%s",
717 adfGetParam);
718
719 pCompressionService->debug_file =
720 LAC_OS_MALLOC(sizeof(debug_file_info_t));
721 if (NULL == pCompressionService->debug_file) {
722 Lac_MemPoolDestroy(
723 pCompressionService->compression_mem_pool);
724
725 icp_adf_transReleaseHandle(
726 pCompressionService->trans_handle_compression_tx);
727
728 icp_adf_transReleaseHandle(
729 pCompressionService->trans_handle_compression_rx);
730 LAC_OS_FREE(instance_name);
731 return CPA_STATUS_RESOURCE;
732 }
733
734 memset(pCompressionService->debug_file,
735 0,
736 sizeof(debug_file_info_t));
737 pCompressionService->debug_file->name = instance_name;
738 pCompressionService->debug_file->seq_read =
739 SalCtrl_CompresionDebug;
740 pCompressionService->debug_file->private_data =
741 pCompressionService;
742 pCompressionService->debug_file->parent =
743 pCompressionService->generic_service_info.debug_parent_dir;
744
745 status = icp_adf_debugAddFile(device,
746 pCompressionService->debug_file);
747 if (CPA_STATUS_SUCCESS != status) {
748 Lac_MemPoolDestroy(
749 pCompressionService->compression_mem_pool);
750
751 icp_adf_transReleaseHandle(
752 pCompressionService->trans_handle_compression_tx);
753
754 icp_adf_transReleaseHandle(
755 pCompressionService->trans_handle_compression_rx);
756 LAC_OS_FREE(instance_name);
757 LAC_OS_FREE(pCompressionService->debug_file);
758 return status;
759 }
760 }
761 pCompressionService->generic_service_info.stats = pStatsCollection;
762 pCompressionService->generic_service_info.state =
763 SAL_SERVICE_STATE_INITIALIZED;
764
765 return status;
766 }
767
768 CpaStatus
SalCtrl_CompressionStart(icp_accel_dev_t * device,sal_service_t * service)769 SalCtrl_CompressionStart(icp_accel_dev_t *device, sal_service_t *service)
770 {
771 CpaStatus status = CPA_STATUS_SUCCESS;
772
773 sal_compression_service_t *pCompressionService =
774 (sal_compression_service_t *)service;
775
776 if (SAL_SERVICE_STATE_INITIALIZED !=
777 pCompressionService->generic_service_info.state) {
778 QAT_UTILS_LOG("Not in the correct state to call start.\n");
779 return CPA_STATUS_FAIL;
780 }
781 /**************************************************************/
782 /* Obtain Extended Features. I.e. Compress And Verify */
783 /**************************************************************/
784 pCompressionService->generic_service_info.dcExtendedFeatures =
785 device->dcExtendedFeatures;
786 pCompressionService->generic_service_info.state =
787 SAL_SERVICE_STATE_RUNNING;
788
789 return status;
790 }
791
792 CpaStatus
SalCtrl_CompressionStop(icp_accel_dev_t * device,sal_service_t * service)793 SalCtrl_CompressionStop(icp_accel_dev_t *device, sal_service_t *service)
794 {
795 sal_compression_service_t *pCompressionService =
796 (sal_compression_service_t *)service;
797
798 if (SAL_SERVICE_STATE_RUNNING !=
799 pCompressionService->generic_service_info.state) {
800 QAT_UTILS_LOG("Not in the correct state to call stop.\n");
801 return CPA_STATUS_FAIL;
802 }
803
804 if (icp_adf_is_dev_in_reset(device)) {
805 pCompressionService->generic_service_info.state =
806 SAL_SERVICE_STATE_RESTARTING;
807 return CPA_STATUS_SUCCESS;
808 }
809
810 pCompressionService->generic_service_info.state =
811 SAL_SERVICE_STATE_SHUTTING_DOWN;
812 return CPA_STATUS_RETRY;
813 }
814
815 CpaStatus
SalCtrl_CompressionShutdown(icp_accel_dev_t * device,sal_service_t * service)816 SalCtrl_CompressionShutdown(icp_accel_dev_t *device, sal_service_t *service)
817 {
818 CpaStatus status = CPA_STATUS_SUCCESS;
819
820 sal_compression_service_t *pCompressionService =
821 (sal_compression_service_t *)service;
822 sal_statistics_collection_t *pStatsCollection =
823 (sal_statistics_collection_t *)device->pQatStats;
824
825 if ((SAL_SERVICE_STATE_INITIALIZED !=
826 pCompressionService->generic_service_info.state) &&
827 (SAL_SERVICE_STATE_SHUTTING_DOWN !=
828 pCompressionService->generic_service_info.state) &&
829 (SAL_SERVICE_STATE_RESTARTING !=
830 pCompressionService->generic_service_info.state)) {
831 QAT_UTILS_LOG("Not in the correct state to call shutdown.\n");
832 return CPA_STATUS_FAIL;
833 }
834
835 Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
836
837 status = icp_adf_transReleaseHandle(
838 pCompressionService->trans_handle_compression_tx);
839 LAC_CHECK_STATUS(status);
840
841 status = icp_adf_transReleaseHandle(
842 pCompressionService->trans_handle_compression_rx);
843 LAC_CHECK_STATUS(status);
844
845 if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
846 /* Clean stats */
847 if (NULL != pCompressionService->debug_file) {
848 icp_adf_debugRemoveFile(
849 pCompressionService->debug_file);
850 LAC_OS_FREE(pCompressionService->debug_file->name);
851 LAC_OS_FREE(pCompressionService->debug_file);
852 pCompressionService->debug_file = NULL;
853 }
854 }
855 pCompressionService->generic_service_info.stats = NULL;
856 dcStatsFree(pCompressionService);
857
858 if (icp_adf_is_dev_in_reset(device)) {
859 pCompressionService->generic_service_info.state =
860 SAL_SERVICE_STATE_RESTARTING;
861 return CPA_STATUS_SUCCESS;
862 }
863 pCompressionService->generic_service_info.state =
864 SAL_SERVICE_STATE_SHUTDOWN;
865 return status;
866 }
867
868 CpaStatus
cpaDcGetStatusText(const CpaInstanceHandle dcInstance,const CpaStatus errStatus,Cpa8S * pStatusText)869 cpaDcGetStatusText(const CpaInstanceHandle dcInstance,
870 const CpaStatus errStatus,
871 Cpa8S *pStatusText)
872 {
873 CpaStatus status = CPA_STATUS_SUCCESS;
874
875 LAC_CHECK_NULL_PARAM(pStatusText);
876
877 switch (errStatus) {
878 case CPA_STATUS_SUCCESS:
879 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_SUCCESS);
880 break;
881 case CPA_STATUS_FAIL:
882 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FAIL);
883 break;
884 case CPA_STATUS_RETRY:
885 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RETRY);
886 break;
887 case CPA_STATUS_RESOURCE:
888 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RESOURCE);
889 break;
890 case CPA_STATUS_INVALID_PARAM:
891 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_INVALID_PARAM);
892 break;
893 case CPA_STATUS_FATAL:
894 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FATAL);
895 break;
896 case CPA_STATUS_UNSUPPORTED:
897 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_UNSUPPORTED);
898 break;
899 default:
900 status = CPA_STATUS_INVALID_PARAM;
901 break;
902 }
903
904 return status;
905 }
906
907 CpaStatus
cpaDcGetNumIntermediateBuffers(CpaInstanceHandle dcInstance,Cpa16U * pNumBuffers)908 cpaDcGetNumIntermediateBuffers(CpaInstanceHandle dcInstance,
909 Cpa16U *pNumBuffers)
910 {
911 CpaInstanceHandle insHandle = NULL;
912 sal_compression_service_t *pService = NULL;
913
914 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
915 insHandle = dcGetFirstHandle();
916 } else {
917 insHandle = dcInstance;
918 }
919
920 LAC_CHECK_NULL_PARAM(insHandle);
921 LAC_CHECK_NULL_PARAM(pNumBuffers);
922
923 pService = (sal_compression_service_t *)insHandle;
924 *pNumBuffers = pService->numInterBuffs;
925
926 return CPA_STATUS_SUCCESS;
927 }
928
929 CpaStatus
cpaDcStartInstance(CpaInstanceHandle instanceHandle,Cpa16U numBuffers,CpaBufferList ** pIntermediateBufferPtrsArray)930 cpaDcStartInstance(CpaInstanceHandle instanceHandle,
931 Cpa16U numBuffers,
932 CpaBufferList **pIntermediateBufferPtrsArray)
933 {
934 icp_qat_addr_width_t *pInterBuffPtrsArray = NULL;
935 icp_qat_addr_width_t pArrayBufferListDescPhyAddr = 0;
936 icp_qat_addr_width_t bufListDescPhyAddr;
937 icp_qat_addr_width_t bufListAlignedPhyAddr;
938 CpaFlatBuffer *pClientCurrFlatBuffer = NULL;
939 icp_buffer_list_desc_t *pBufferListDesc = NULL;
940 icp_flat_buffer_desc_t *pCurrFlatBufDesc = NULL;
941 CpaInstanceInfo2 info = { 0 };
942 icp_accel_dev_t *dev = NULL;
943 CpaStatus status = CPA_STATUS_SUCCESS;
944 sal_compression_service_t *pService = NULL;
945 CpaInstanceHandle insHandle = NULL;
946 Cpa16U bufferIndex = 0;
947 Cpa32U numFlatBuffers = 0;
948 Cpa64U clientListSize = 0;
949 CpaBufferList *pClientCurrentIntermediateBuffer = NULL;
950 Cpa32U bufferIndex2 = 0;
951 CpaBufferList **pTempIntermediateBufferPtrsArray;
952 Cpa64U lastClientListSize = 0;
953
954 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
955 insHandle = dcGetFirstHandle();
956 } else {
957 insHandle = instanceHandle;
958 }
959 LAC_CHECK_NULL_PARAM(insHandle);
960
961 status = cpaDcInstanceGetInfo2(insHandle, &info);
962 if (CPA_STATUS_SUCCESS != status) {
963 QAT_UTILS_LOG("Can not get instance info.\n");
964 return status;
965 }
966
967 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
968 if (NULL == dev) {
969 QAT_UTILS_LOG("Can not find device for the instance\n");
970 return CPA_STATUS_FAIL;
971 }
972
973 if (NULL == pIntermediateBufferPtrsArray) {
974 /* Increment dev ref counter and return - DRAM is not used */
975 icp_qa_dev_get(dev);
976 return CPA_STATUS_SUCCESS;
977 }
978
979 if (0 == numBuffers) {
980 /* Increment dev ref counter and return - DRAM is not used */
981 icp_qa_dev_get(dev);
982 return CPA_STATUS_SUCCESS;
983 }
984
985 pService = (sal_compression_service_t *)insHandle;
986
987 LAC_CHECK_NULL_PARAM(insHandle);
988
989 if ((numBuffers > 0) && (NULL == pIntermediateBufferPtrsArray)) {
990 QAT_UTILS_LOG("Invalid Intermediate Buffers Array pointer\n");
991 return CPA_STATUS_INVALID_PARAM;
992 }
993
994 /* Check number of intermediate buffers allocated by user */
995 if ((pService->numInterBuffs != numBuffers)) {
996 QAT_UTILS_LOG("Invalid number of buffers\n");
997 return CPA_STATUS_INVALID_PARAM;
998 }
999
1000 pTempIntermediateBufferPtrsArray = pIntermediateBufferPtrsArray;
1001 for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
1002 if (NULL == *pTempIntermediateBufferPtrsArray) {
1003 QAT_UTILS_LOG(
1004 "Intermediate Buffer - Invalid Buffer List pointer\n");
1005 return CPA_STATUS_INVALID_PARAM;
1006 }
1007
1008 if (NULL == (*pTempIntermediateBufferPtrsArray)->pBuffers) {
1009 QAT_UTILS_LOG(
1010 "Intermediate Buffer - Invalid Flat Buffer descriptor pointer\n");
1011 return CPA_STATUS_INVALID_PARAM;
1012 }
1013
1014 if (NULL ==
1015 (*pTempIntermediateBufferPtrsArray)->pPrivateMetaData) {
1016 QAT_UTILS_LOG(
1017 "Intermediate Buffer - Invalid Private MetaData descriptor pointer\n");
1018 return CPA_STATUS_INVALID_PARAM;
1019 }
1020
1021 clientListSize = 0;
1022 for (bufferIndex2 = 0; bufferIndex2 <
1023 (*pTempIntermediateBufferPtrsArray)->numBuffers;
1024 bufferIndex2++) {
1025
1026 if ((0 !=
1027 (*pTempIntermediateBufferPtrsArray)
1028 ->pBuffers[bufferIndex2]
1029 .dataLenInBytes) &&
1030 NULL ==
1031 (*pTempIntermediateBufferPtrsArray)
1032 ->pBuffers[bufferIndex2]
1033 .pData) {
1034 QAT_UTILS_LOG(
1035 "Intermediate Buffer - Invalid Flat Buffer pointer\n");
1036 return CPA_STATUS_INVALID_PARAM;
1037 }
1038
1039 clientListSize += (*pTempIntermediateBufferPtrsArray)
1040 ->pBuffers[bufferIndex2]
1041 .dataLenInBytes;
1042 }
1043
1044 if (bufferIndex != 0) {
1045 if (lastClientListSize != clientListSize) {
1046 QAT_UTILS_LOG(
1047 "SGLs have to be of the same size.\n");
1048 return CPA_STATUS_INVALID_PARAM;
1049 }
1050 } else {
1051 lastClientListSize = clientListSize;
1052 }
1053 pTempIntermediateBufferPtrsArray++;
1054 }
1055
1056 /* Allocate array of physical pointers to icp_buffer_list_desc_t */
1057 status = LAC_OS_CAMALLOC(&pInterBuffPtrsArray,
1058 (numBuffers * sizeof(icp_qat_addr_width_t)),
1059 LAC_64BYTE_ALIGNMENT,
1060 pService->nodeAffinity);
1061 if (CPA_STATUS_SUCCESS != status) {
1062 QAT_UTILS_LOG("Can not allocate Intermediate Buffers array.\n");
1063 return status;
1064 }
1065
1066 /* Get physical address of the intermediate buffer pointers array */
1067 pArrayBufferListDescPhyAddr = LAC_MEM_CAST_PTR_TO_UINT64(
1068 LAC_OS_VIRT_TO_PHYS_INTERNAL(pInterBuffPtrsArray));
1069
1070 pService->pInterBuffPtrsArray = pInterBuffPtrsArray;
1071 pService->pInterBuffPtrsArrayPhyAddr = pArrayBufferListDescPhyAddr;
1072
1073 /* Get the full size of the buffer list */
1074 /* Assumption: all the SGLs allocated by the user have the same size */
1075 clientListSize = 0;
1076 for (bufferIndex = 0;
1077 bufferIndex < (*pIntermediateBufferPtrsArray)->numBuffers;
1078 bufferIndex++) {
1079 clientListSize += ((*pIntermediateBufferPtrsArray)
1080 ->pBuffers[bufferIndex]
1081 .dataLenInBytes);
1082 }
1083 pService->minInterBuffSizeInBytes = clientListSize;
1084
1085 for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
1086
1087 /* Get pointer to the client Intermediate Buffer List
1088 * (CpaBufferList) */
1089 pClientCurrentIntermediateBuffer =
1090 *pIntermediateBufferPtrsArray;
1091
1092 /* Get number of flat buffers in the buffer list */
1093 numFlatBuffers = pClientCurrentIntermediateBuffer->numBuffers;
1094
1095 /* Get pointer to the client array of CpaFlatBuffers */
1096 pClientCurrFlatBuffer =
1097 pClientCurrentIntermediateBuffer->pBuffers;
1098
1099 /* Calculate Physical address of current private SGL */
1100 bufListDescPhyAddr = LAC_OS_VIRT_TO_PHYS_EXTERNAL(
1101 (*pService),
1102 pClientCurrentIntermediateBuffer->pPrivateMetaData);
1103 if (bufListDescPhyAddr == 0) {
1104 QAT_UTILS_LOG(
1105 "Unable to get the physical address of the metadata.\n");
1106 return CPA_STATUS_FAIL;
1107 }
1108
1109 /* Align SGL physical address */
1110 bufListAlignedPhyAddr =
1111 LAC_ALIGN_POW2_ROUNDUP(bufListDescPhyAddr,
1112 ICP_DESCRIPTOR_ALIGNMENT_BYTES);
1113
1114 /* Set physical address of the Intermediate Buffer SGL in the
1115 * SGLs array
1116 */
1117 *pInterBuffPtrsArray =
1118 LAC_MEM_CAST_PTR_TO_UINT64(bufListAlignedPhyAddr);
1119
1120 /* Calculate (virtual) offset to the buffer list descriptor */
1121 pBufferListDesc =
1122 (icp_buffer_list_desc_t
1123 *)((LAC_ARCH_UINT)pClientCurrentIntermediateBuffer
1124 ->pPrivateMetaData +
1125 (LAC_ARCH_UINT)(bufListAlignedPhyAddr -
1126 bufListDescPhyAddr));
1127
1128 /* Set number of flat buffers in the physical Buffer List
1129 * descriptor */
1130 pBufferListDesc->numBuffers = numFlatBuffers;
1131
1132 /* Go past the Buffer List descriptor to the list of buffer
1133 * descriptors
1134 */
1135 pCurrFlatBufDesc =
1136 (icp_flat_buffer_desc_t *)((pBufferListDesc->phyBuffers));
1137
1138 /* Loop for each flat buffer in the SGL */
1139 while (0 != numFlatBuffers) {
1140 /* Set length of the current flat buffer */
1141 pCurrFlatBufDesc->dataLenInBytes =
1142 pClientCurrFlatBuffer->dataLenInBytes;
1143
1144 /* Set physical address of the flat buffer */
1145 pCurrFlatBufDesc->phyBuffer =
1146 LAC_MEM_CAST_PTR_TO_UINT64(
1147 LAC_OS_VIRT_TO_PHYS_EXTERNAL(
1148 (*pService), pClientCurrFlatBuffer->pData));
1149
1150 if (pCurrFlatBufDesc->phyBuffer == 0) {
1151 QAT_UTILS_LOG(
1152 "Unable to get the physical address of the flat buffer.\n");
1153 return CPA_STATUS_FAIL;
1154 }
1155
1156 pCurrFlatBufDesc++;
1157 pClientCurrFlatBuffer++;
1158 numFlatBuffers--;
1159 }
1160 pIntermediateBufferPtrsArray++;
1161 pInterBuffPtrsArray++;
1162 }
1163
1164 pService->generic_service_info.isInstanceStarted = CPA_TRUE;
1165
1166 /* Increment dev ref counter */
1167 icp_qa_dev_get(dev);
1168 return CPA_STATUS_SUCCESS;
1169 }
1170
1171 CpaStatus
cpaDcStopInstance(CpaInstanceHandle instanceHandle)1172 cpaDcStopInstance(CpaInstanceHandle instanceHandle)
1173 {
1174 CpaInstanceHandle insHandle = NULL;
1175 CpaInstanceInfo2 info = { 0 };
1176 icp_accel_dev_t *dev = NULL;
1177 CpaStatus status = CPA_STATUS_SUCCESS;
1178 sal_compression_service_t *pService = NULL;
1179
1180 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1181 insHandle = dcGetFirstHandle();
1182 } else {
1183 insHandle = instanceHandle;
1184 }
1185
1186 LAC_CHECK_NULL_PARAM(insHandle);
1187 pService = (sal_compression_service_t *)insHandle;
1188
1189 /* Free Intermediate Buffer Pointers Array */
1190 if (pService->pInterBuffPtrsArray != NULL) {
1191 LAC_OS_CAFREE(pService->pInterBuffPtrsArray);
1192 pService->pInterBuffPtrsArray = 0;
1193 }
1194
1195 pService->pInterBuffPtrsArrayPhyAddr = 0;
1196
1197 status = cpaDcInstanceGetInfo2(insHandle, &info);
1198 if (CPA_STATUS_SUCCESS != status) {
1199 QAT_UTILS_LOG("Can not get instance info.\n");
1200 return status;
1201 }
1202 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
1203 if (NULL == dev) {
1204 QAT_UTILS_LOG("Can not find device for the instance.\n");
1205 return CPA_STATUS_FAIL;
1206 }
1207
1208 pService->generic_service_info.isInstanceStarted = CPA_FALSE;
1209
1210 /* Decrement dev ref counter */
1211 icp_qa_dev_put(dev);
1212 return CPA_STATUS_SUCCESS;
1213 }
1214
1215 CpaStatus
cpaDcGetNumInstances(Cpa16U * pNumInstances)1216 cpaDcGetNumInstances(Cpa16U *pNumInstances)
1217 {
1218 CpaStatus status = CPA_STATUS_SUCCESS;
1219 icp_accel_dev_t **pAdfInsts = NULL;
1220 icp_accel_dev_t *dev_addr = NULL;
1221 sal_t *base_addr = NULL;
1222 sal_list_t *list_temp = NULL;
1223 Cpa16U num_accel_dev = 0;
1224 Cpa16U num = 0;
1225 Cpa16U i = 0;
1226
1227 LAC_CHECK_NULL_PARAM(pNumInstances);
1228
1229 /* Get the number of accel_dev in the system */
1230 status = icp_amgr_getNumInstances(&num_accel_dev);
1231 LAC_CHECK_STATUS(status);
1232
1233 /* Allocate memory to store addr of accel_devs */
1234 pAdfInsts =
1235 malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
1236 num_accel_dev = 0;
1237
1238 /* Get ADF to return accel_devs with dc enabled */
1239 status = icp_amgr_getAllAccelDevByCapabilities(
1240 ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
1241 if (CPA_STATUS_SUCCESS == status) {
1242 for (i = 0; i < num_accel_dev; i++) {
1243 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1244 if (NULL != dev_addr) {
1245 base_addr = dev_addr->pSalHandle;
1246 if (NULL != base_addr) {
1247 list_temp =
1248 base_addr->compression_services;
1249 while (NULL != list_temp) {
1250 num++;
1251 list_temp =
1252 SalList_next(list_temp);
1253 }
1254 }
1255 }
1256 }
1257
1258 *pNumInstances = num;
1259 }
1260
1261 free(pAdfInsts, M_QAT);
1262
1263 return status;
1264 }
1265
1266 CpaStatus
cpaDcGetInstances(Cpa16U numInstances,CpaInstanceHandle * dcInstances)1267 cpaDcGetInstances(Cpa16U numInstances, CpaInstanceHandle *dcInstances)
1268 {
1269 CpaStatus status = CPA_STATUS_SUCCESS;
1270 icp_accel_dev_t **pAdfInsts = NULL;
1271 icp_accel_dev_t *dev_addr = NULL;
1272 sal_t *base_addr = NULL;
1273 sal_list_t *list_temp = NULL;
1274 Cpa16U num_accel_dev = 0;
1275 Cpa16U index = 0;
1276 Cpa16U i = 0;
1277
1278 LAC_CHECK_NULL_PARAM(dcInstances);
1279 if (0 == numInstances) {
1280 QAT_UTILS_LOG("numInstances is 0.\n");
1281 return CPA_STATUS_INVALID_PARAM;
1282 }
1283
1284 /* Get the number of accel_dev in the system */
1285 status = icp_amgr_getNumInstances(&num_accel_dev);
1286 LAC_CHECK_STATUS(status);
1287
1288 /* Allocate memory to store addr of accel_devs */
1289 pAdfInsts =
1290 malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
1291
1292 num_accel_dev = 0;
1293 /* Get ADF to return accel_devs with dc enabled */
1294 status = icp_amgr_getAllAccelDevByCapabilities(
1295 ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
1296
1297 if (CPA_STATUS_SUCCESS == status) {
1298 /* First check the number of instances in the system */
1299 for (i = 0; i < num_accel_dev; i++) {
1300 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1301 if (NULL != dev_addr) {
1302 base_addr = dev_addr->pSalHandle;
1303 if (NULL != base_addr) {
1304 list_temp =
1305 base_addr->compression_services;
1306 while (NULL != list_temp) {
1307 if (index >
1308 (numInstances - 1)) {
1309 break;
1310 }
1311
1312 dcInstances[index] =
1313 SalList_getObject(
1314 list_temp);
1315 list_temp =
1316 SalList_next(list_temp);
1317 index++;
1318 }
1319 }
1320 }
1321 }
1322
1323 if (numInstances > index) {
1324 QAT_UTILS_LOG("Only %d dc instances available.\n",
1325 index);
1326 status = CPA_STATUS_RESOURCE;
1327 }
1328 }
1329
1330 if (CPA_STATUS_SUCCESS == status) {
1331 index = 0;
1332 for (i = 0; i < num_accel_dev; i++) {
1333 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1334 /* Note dev_addr cannot be NULL here as numInstances=0
1335 is not valid and if dev_addr=NULL then index=0 (which
1336 is less than numInstances and status is set to
1337 _RESOURCE
1338 above */
1339 base_addr = dev_addr->pSalHandle;
1340 if (NULL != base_addr) {
1341 list_temp = base_addr->compression_services;
1342 while (NULL != list_temp) {
1343 if (index > (numInstances - 1)) {
1344 break;
1345 }
1346
1347 dcInstances[index] =
1348 SalList_getObject(list_temp);
1349 list_temp = SalList_next(list_temp);
1350 index++;
1351 }
1352 }
1353 }
1354 }
1355
1356 free(pAdfInsts, M_QAT);
1357
1358 return status;
1359 }
1360
1361 CpaStatus
cpaDcInstanceGetInfo2(const CpaInstanceHandle instanceHandle,CpaInstanceInfo2 * pInstanceInfo2)1362 cpaDcInstanceGetInfo2(const CpaInstanceHandle instanceHandle,
1363 CpaInstanceInfo2 *pInstanceInfo2)
1364 {
1365 sal_compression_service_t *pCompressionService = NULL;
1366 CpaInstanceHandle insHandle = NULL;
1367 icp_accel_dev_t *dev = NULL;
1368 CpaStatus status = CPA_STATUS_SUCCESS;
1369 char keyStr[ADF_CFG_MAX_KEY_LEN_IN_BYTES] = { 0 };
1370 char valStr[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
1371 char *section = DYN_SEC;
1372
1373 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1374 insHandle = dcGetFirstHandle();
1375 } else {
1376 insHandle = instanceHandle;
1377 }
1378
1379 LAC_CHECK_NULL_PARAM(insHandle);
1380 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1381 LAC_CHECK_NULL_PARAM(pInstanceInfo2);
1382
1383 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1384 pInstanceInfo2->accelerationServiceType =
1385 CPA_ACC_SVC_TYPE_DATA_COMPRESSION;
1386
1387 snprintf((char *)pInstanceInfo2->vendorName,
1388 CPA_INST_VENDOR_NAME_SIZE,
1389 "%s",
1390 SAL_INFO2_VENDOR_NAME);
1391 pInstanceInfo2->vendorName[CPA_INST_VENDOR_NAME_SIZE - 1] = '\0';
1392
1393 snprintf((char *)pInstanceInfo2->swVersion,
1394 CPA_INST_SW_VERSION_SIZE,
1395 "Version %d.%d",
1396 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER,
1397 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER);
1398 pInstanceInfo2->swVersion[CPA_INST_SW_VERSION_SIZE - 1] = '\0';
1399
1400 /* Note we can safely read the contents of the compression service
1401 instance
1402 here because icp_amgr_getAccelDevByCapabilities() only returns devs
1403 that have started */
1404 pCompressionService = (sal_compression_service_t *)insHandle;
1405 pInstanceInfo2->physInstId.packageId = pCompressionService->pkgID;
1406 pInstanceInfo2->physInstId.acceleratorId =
1407 pCompressionService->acceleratorNum;
1408 pInstanceInfo2->physInstId.executionEngineId = 0;
1409 pInstanceInfo2->physInstId.busAddress =
1410 icp_adf_get_busAddress(pInstanceInfo2->physInstId.packageId);
1411
1412 /* set coreAffinity to zero before use */
1413 LAC_OS_BZERO(pInstanceInfo2->coreAffinity,
1414 sizeof(pInstanceInfo2->coreAffinity));
1415 CPA_BITMAP_BIT_SET(pInstanceInfo2->coreAffinity,
1416 pCompressionService->coreAffinity);
1417
1418 pInstanceInfo2->nodeAffinity = pCompressionService->nodeAffinity;
1419
1420 if (CPA_TRUE ==
1421 pCompressionService->generic_service_info.isInstanceStarted) {
1422 pInstanceInfo2->operState = CPA_OPER_STATE_UP;
1423 } else {
1424 pInstanceInfo2->operState = CPA_OPER_STATE_DOWN;
1425 }
1426
1427 pInstanceInfo2->requiresPhysicallyContiguousMemory = CPA_TRUE;
1428
1429 if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
1430 pInstanceInfo2->isPolled = CPA_TRUE;
1431 } else {
1432 pInstanceInfo2->isPolled = CPA_FALSE;
1433 }
1434
1435 pInstanceInfo2->isOffloaded = CPA_TRUE;
1436 /* Get the instance name and part name from the config file */
1437 dev = icp_adf_getAccelDevByAccelId(pCompressionService->pkgID);
1438 if (NULL == dev ||
1439 0 == strnlen(dev->deviceName, ADF_DEVICE_TYPE_LENGTH + 1)) {
1440 QAT_UTILS_LOG("Can not find device for the instance.\n");
1441 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1442 return CPA_STATUS_FAIL;
1443 }
1444 snprintf((char *)pInstanceInfo2->partName,
1445 CPA_INST_PART_NAME_SIZE,
1446 SAL_INFO2_PART_NAME,
1447 dev->deviceName);
1448 pInstanceInfo2->partName[CPA_INST_PART_NAME_SIZE - 1] = '\0';
1449
1450 if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
1451 section = icpGetProcessName();
1452 }
1453
1454 status = Sal_StringParsing(
1455 "Dc",
1456 pCompressionService->generic_service_info.instance,
1457 "Name",
1458 keyStr);
1459 LAC_CHECK_STATUS(status);
1460 status = icp_adf_cfgGetParamValue(dev, section, keyStr, valStr);
1461 LAC_CHECK_STATUS(status);
1462 strncpy((char *)pInstanceInfo2->instName,
1463 valStr,
1464 sizeof(pInstanceInfo2->instName) - 1);
1465 pInstanceInfo2->instName[CPA_INST_NAME_SIZE - 1] = '\0';
1466
1467 #if __GNUC__ >= 7
1468 #pragma GCC diagnostic push
1469 #pragma GCC diagnostic ignored "-Wformat-truncation"
1470 #endif
1471 snprintf((char *)pInstanceInfo2->instID,
1472 CPA_INST_ID_SIZE,
1473 "%s_%s",
1474 section,
1475 valStr);
1476 #if __GNUC__ >= 7
1477 #pragma GCC diagnostic pop
1478 #endif
1479
1480 return CPA_STATUS_SUCCESS;
1481 }
1482
1483 CpaStatus
cpaDcQueryCapabilities(CpaInstanceHandle dcInstance,CpaDcInstanceCapabilities * pInstanceCapabilities)1484 cpaDcQueryCapabilities(CpaInstanceHandle dcInstance,
1485 CpaDcInstanceCapabilities *pInstanceCapabilities)
1486 {
1487 CpaInstanceHandle insHandle = NULL;
1488 sal_compression_service_t *pService = NULL;
1489 Cpa32U capabilitiesMask = 0;
1490 dc_extd_ftrs_t *pExtendedFtrs = NULL;
1491
1492 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1493 insHandle = dcGetFirstHandle();
1494 if (NULL == insHandle) {
1495 QAT_UTILS_LOG("Can not get the instance.\n");
1496 return CPA_STATUS_FAIL;
1497 }
1498 } else {
1499 insHandle = dcInstance;
1500 }
1501
1502 pService = (sal_compression_service_t *)insHandle;
1503
1504 LAC_CHECK_NULL_PARAM(insHandle);
1505 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1506 LAC_CHECK_NULL_PARAM(pInstanceCapabilities);
1507
1508 memset(pInstanceCapabilities, 0, sizeof(CpaDcInstanceCapabilities));
1509
1510 capabilitiesMask = pService->generic_service_info.capabilitiesMask;
1511
1512 /* Set compression capabilities */
1513 if (capabilitiesMask & ICP_ACCEL_CAPABILITIES_CNV_INTEGRITY) {
1514 pInstanceCapabilities->integrityCrcs = CPA_TRUE;
1515 }
1516
1517 pInstanceCapabilities->endOfLastBlock = CPA_TRUE;
1518 pInstanceCapabilities->statefulDeflateCompression = CPA_FALSE;
1519 pInstanceCapabilities->statefulDeflateDecompression = CPA_TRUE;
1520 pInstanceCapabilities->statelessDeflateCompression = CPA_TRUE;
1521 pInstanceCapabilities->statelessDeflateDecompression = CPA_TRUE;
1522 pInstanceCapabilities->checksumCRC32 = CPA_TRUE;
1523 pInstanceCapabilities->checksumAdler32 = CPA_TRUE;
1524 pInstanceCapabilities->dynamicHuffman = CPA_TRUE;
1525 pInstanceCapabilities->precompiledHuffman = CPA_FALSE;
1526 pInstanceCapabilities->dynamicHuffmanBufferReq = CPA_TRUE;
1527 pInstanceCapabilities->autoSelectBestHuffmanTree = CPA_TRUE;
1528
1529 pInstanceCapabilities->validWindowSizeMaskCompression =
1530 pService->comp_device_data.windowSizeMask;
1531 pInstanceCapabilities->validWindowSizeMaskDecompression =
1532 pService->comp_device_data.windowSizeMask;
1533 pExtendedFtrs = (dc_extd_ftrs_t *)&(
1534 ((sal_service_t *)insHandle)->dcExtendedFeatures);
1535 pInstanceCapabilities->batchAndPack = CPA_FALSE;
1536 pInstanceCapabilities->compressAndVerify =
1537 (CpaBoolean)pExtendedFtrs->is_cnv;
1538 pInstanceCapabilities->compressAndVerifyStrict = CPA_TRUE;
1539 pInstanceCapabilities->compressAndVerifyAndRecover =
1540 (CpaBoolean)pExtendedFtrs->is_cnvnr;
1541 return CPA_STATUS_SUCCESS;
1542 }
1543
1544 CpaStatus
cpaDcSetAddressTranslation(const CpaInstanceHandle instanceHandle,CpaVirtualToPhysical virtual2Physical)1545 cpaDcSetAddressTranslation(const CpaInstanceHandle instanceHandle,
1546 CpaVirtualToPhysical virtual2Physical)
1547 {
1548 sal_service_t *pService = NULL;
1549 CpaInstanceHandle insHandle = NULL;
1550
1551 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1552 insHandle = dcGetFirstHandle();
1553 } else {
1554 insHandle = instanceHandle;
1555 }
1556
1557 LAC_CHECK_NULL_PARAM(insHandle);
1558 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1559 LAC_CHECK_NULL_PARAM(virtual2Physical);
1560
1561 pService = (sal_service_t *)insHandle;
1562
1563 pService->virt2PhysClient = virtual2Physical;
1564
1565 return CPA_STATUS_SUCCESS;
1566 }
1567
1568 /**
1569 ******************************************************************************
1570 * @ingroup cpaDcCommon
1571 * Data compression specific polling function which polls a DC instance.
1572 *****************************************************************************/
1573
1574 CpaStatus
icp_sal_DcPollInstance(CpaInstanceHandle instanceHandle_in,Cpa32U response_quota)1575 icp_sal_DcPollInstance(CpaInstanceHandle instanceHandle_in,
1576 Cpa32U response_quota)
1577 {
1578 CpaStatus status = CPA_STATUS_SUCCESS;
1579 sal_compression_service_t *dc_handle = NULL;
1580 sal_service_t *gen_handle = NULL;
1581 icp_comms_trans_handle trans_hndTable[DC_NUM_RX_RINGS];
1582
1583 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1584 dc_handle = (sal_compression_service_t *)dcGetFirstHandle();
1585 } else {
1586 dc_handle = (sal_compression_service_t *)instanceHandle_in;
1587 }
1588
1589 LAC_CHECK_NULL_PARAM(dc_handle);
1590 SAL_RUNNING_CHECK(dc_handle);
1591
1592 gen_handle = &(dc_handle->generic_service_info);
1593 if (SAL_SERVICE_TYPE_COMPRESSION != gen_handle->type) {
1594 QAT_UTILS_LOG("Instance handle type is incorrect.\n");
1595 return CPA_STATUS_FAIL;
1596 }
1597
1598 /*
1599 * From the instanceHandle we must get the trans_handle and send
1600 * down to adf for polling.
1601 * Populate our trans handle table with the appropriate handles.
1602 */
1603 trans_hndTable[0] = dc_handle->trans_handle_compression_rx;
1604
1605 /* Call adf to do the polling. */
1606 status = icp_adf_pollInstance(trans_hndTable,
1607 DC_NUM_RX_RINGS,
1608 response_quota);
1609 return status;
1610 }
1611
1612 /**
1613 ******************************************************************************
1614 * @ingroup cpaDcCommon
1615 *****************************************************************************/
1616 CpaStatus
cpaDcInstanceSetNotificationCb(const CpaInstanceHandle instanceHandle,const CpaDcInstanceNotificationCbFunc pInstanceNotificationCb,void * pCallbackTag)1617 cpaDcInstanceSetNotificationCb(
1618 const CpaInstanceHandle instanceHandle,
1619 const CpaDcInstanceNotificationCbFunc pInstanceNotificationCb,
1620 void *pCallbackTag)
1621 {
1622 CpaStatus status = CPA_STATUS_SUCCESS;
1623 sal_service_t *gen_handle = instanceHandle;
1624
1625 LAC_CHECK_NULL_PARAM(gen_handle);
1626 gen_handle->notification_cb = pInstanceNotificationCb;
1627 gen_handle->cb_tag = pCallbackTag;
1628 return status;
1629 }
1630
1631 CpaInstanceHandle
dcGetFirstHandle(void)1632 dcGetFirstHandle(void)
1633 {
1634 CpaStatus status = CPA_STATUS_SUCCESS;
1635 static icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES] = { 0 };
1636 CpaInstanceHandle dcInst = NULL;
1637 icp_accel_dev_t *dev_addr = NULL;
1638 sal_t *base_addr = NULL;
1639 sal_list_t *list_temp = NULL;
1640 Cpa16U i, num_dc = 0;
1641
1642 /* Only need 1 dev with compression enabled - so check all devices */
1643 status = icp_amgr_getAllAccelDevByCapabilities(
1644 ICP_ACCEL_CAPABILITIES_COMPRESSION, adfInsts, &num_dc);
1645 if ((0 == num_dc) || (CPA_STATUS_SUCCESS != status)) {
1646 QAT_UTILS_LOG(
1647 "No compression devices enabled in the system.\n");
1648 return dcInst;
1649 }
1650
1651 for (i = 0; i < num_dc; i++) {
1652 dev_addr = (icp_accel_dev_t *)adfInsts[i];
1653 if (NULL != dev_addr) {
1654 base_addr = dev_addr->pSalHandle;
1655 if (NULL != base_addr) {
1656 list_temp = base_addr->compression_services;
1657 if (NULL != list_temp) {
1658 dcInst = SalList_getObject(list_temp);
1659 break;
1660 }
1661 }
1662 }
1663 }
1664 return dcInst;
1665 }
1666