1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2022 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 pCompressionService->generic_service_info.state =
375 SAL_SERVICE_STATE_INITIALIZING;
376
377 if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
378 section = icpGetProcessName();
379 }
380
381 if (pStatsCollection == NULL) {
382 return CPA_STATUS_FAIL;
383 }
384
385 /* Get Config Info: Accel Num, bank Num, packageID,
386 coreAffinity, nodeAffinity and response mode
387 */
388
389 pCompressionService->acceleratorNum = 0;
390
391 /* Initialise device specific compression data */
392 SalCtrl_CompressionInit_CompData(device, pCompressionService);
393
394 status = Sal_StringParsing(
395 "Dc",
396 pCompressionService->generic_service_info.instance,
397 "BankNumber",
398 temp_string);
399 LAC_CHECK_STATUS(status);
400 status =
401 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
402 if (CPA_STATUS_SUCCESS != status) {
403 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
404 temp_string);
405 return status;
406 }
407
408 pCompressionService->bankNum =
409 Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
410
411 status = Sal_StringParsing(
412 "Dc",
413 pCompressionService->generic_service_info.instance,
414 "IsPolled",
415 temp_string);
416 LAC_CHECK_STATUS(status);
417 status =
418 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
419 if (CPA_STATUS_SUCCESS != status) {
420 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
421 temp_string);
422 return status;
423 }
424 pCompressionService->isPolled =
425 (Cpa8U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
426
427 /* User instances only support poll and epoll mode */
428 if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
429 QAT_UTILS_LOG(
430 "IsPolled %u is not supported for user instance %s.\n",
431 pCompressionService->isPolled,
432 temp_string);
433 return CPA_STATUS_FAIL;
434 }
435
436 if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
437 rx_resp_type = ICP_RESP_TYPE_POLL;
438 }
439
440 status = icp_adf_cfgGetParamValue(device,
441 LAC_CFG_SECTION_GENERAL,
442 ADF_DEV_PKG_ID,
443 adfGetParam);
444 if (CPA_STATUS_SUCCESS != status) {
445 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
446 ADF_DEV_PKG_ID);
447 return status;
448 }
449 pCompressionService->pkgID =
450 (Cpa16U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
451
452 status = icp_adf_cfgGetParamValue(device,
453 LAC_CFG_SECTION_GENERAL,
454 ADF_DEV_NODE_ID,
455 adfGetParam);
456 if (CPA_STATUS_SUCCESS != status) {
457 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
458 ADF_DEV_NODE_ID);
459 return status;
460 }
461 pCompressionService->nodeAffinity =
462 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
463
464 /* In case of interrupt instance, use the bank affinity set by adf_ctl
465 * Otherwise, use the instance affinity for backwards compatibility */
466 if (SAL_RESP_POLL_CFG_FILE != pCompressionService->isPolled) {
467 /* Next need to read the [AcceleratorX] section of the config
468 * file */
469 status = Sal_StringParsing("Accelerator",
470 pCompressionService->acceleratorNum,
471 "",
472 temp_string2);
473 LAC_CHECK_STATUS(status);
474
475 status = Sal_StringParsing("Bank",
476 pCompressionService->bankNum,
477 "CoreAffinity",
478 temp_string);
479 LAC_CHECK_STATUS(status);
480 } else {
481 strncpy(temp_string2,
482 section,
483 sizeof(temp_string2) - SAL_NULL_TERM_SIZE);
484 temp_string2[SAL_CFG_MAX_VAL_LEN_IN_BYTES -
485 SAL_NULL_TERM_SIZE] = '\0';
486
487 status = Sal_StringParsing(
488 "Dc",
489 pCompressionService->generic_service_info.instance,
490 "CoreAffinity",
491 temp_string);
492 LAC_CHECK_STATUS(status);
493 }
494
495 status = icp_adf_cfgGetParamValue(device,
496 temp_string2,
497 temp_string,
498 adfGetParam);
499 if (CPA_STATUS_SUCCESS != status) {
500 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
501 temp_string);
502 return status;
503 }
504 pCompressionService->coreAffinity =
505 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
506
507 status = Sal_StringParsing(
508 "Dc",
509 pCompressionService->generic_service_info.instance,
510 "NumConcurrentRequests",
511 temp_string);
512 LAC_CHECK_STATUS(status);
513 status =
514 icp_adf_cfgGetParamValue(device, section, temp_string, adfGetParam);
515 if (CPA_STATUS_SUCCESS != status) {
516 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
517 temp_string);
518 return status;
519 }
520
521 numCompConcurrentReq =
522 (Cpa32U)Sal_Strtoul(adfGetParam, NULL, SAL_CFG_BASE_DEC);
523 if (validateConcurrRequest(numCompConcurrentReq)) {
524 QAT_UTILS_LOG(
525 "Invalid NumConcurrentRequests, valid values are: {64, 128, 256, ... 32768, 65536}.\n");
526 return CPA_STATUS_FAIL;
527 }
528
529 /* ADF does not allow us to completely fill the ring for batch requests
530 */
531 pCompressionService->maxNumCompConcurrentReq =
532 (numCompConcurrentReq - SAL_BATCH_SUBMIT_FREE_SPACE);
533
534 /* 1. Create transport handles */
535 status = Sal_StringParsing(
536 "Dc",
537 pCompressionService->generic_service_info.instance,
538 "RingTx",
539 temp_string);
540 LAC_CHECK_STATUS(status);
541
542 msgSize = LAC_QAT_DC_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES;
543 status = icp_adf_transCreateHandle(
544 device,
545 ICP_TRANS_TYPE_ETR,
546 section,
547 pCompressionService->acceleratorNum,
548 pCompressionService->bankNum,
549 temp_string,
550 lac_getRingType(SAL_RING_TYPE_DC),
551 NULL,
552 ICP_RESP_TYPE_NONE,
553 numCompConcurrentReq,
554 msgSize,
555 (icp_comms_trans_handle *)&(
556 pCompressionService->trans_handle_compression_tx));
557 LAC_CHECK_STATUS(status);
558
559 if (icp_adf_transGetRingNum(
560 pCompressionService->trans_handle_compression_tx,
561 &request_ring_id) != CPA_STATUS_SUCCESS) {
562 icp_adf_transReleaseHandle(
563 pCompressionService->trans_handle_compression_tx);
564
565 QAT_UTILS_LOG("Failed to get DC TX ring number.\n");
566 return CPA_STATUS_FAIL;
567 }
568
569 status = Sal_StringParsing(
570 "Dc",
571 pCompressionService->generic_service_info.instance,
572 "RingRx",
573 temp_string);
574 if (CPA_STATUS_SUCCESS != status) {
575 icp_adf_transReleaseHandle(
576 pCompressionService->trans_handle_compression_tx);
577 return status;
578 }
579
580 msgSize = LAC_QAT_DC_RESP_SZ_LW * LAC_LONG_WORD_IN_BYTES;
581 status = icp_adf_transCreateHandle(
582 device,
583 ICP_TRANS_TYPE_ETR,
584 section,
585 pCompressionService->acceleratorNum,
586 pCompressionService->bankNum,
587 temp_string,
588 lac_getRingType(SAL_RING_TYPE_NONE),
589 (icp_trans_callback)dcCompression_ProcessCallback,
590 rx_resp_type,
591 numCompConcurrentReq,
592 msgSize,
593 (icp_comms_trans_handle *)&(
594 pCompressionService->trans_handle_compression_rx));
595 if (CPA_STATUS_SUCCESS != status) {
596 icp_adf_transReleaseHandle(
597 pCompressionService->trans_handle_compression_tx);
598 return status;
599 }
600
601 if (icp_adf_transGetRingNum(
602 pCompressionService->trans_handle_compression_rx,
603 &response_ring_id) != CPA_STATUS_SUCCESS) {
604 icp_adf_transReleaseHandle(
605 pCompressionService->trans_handle_compression_tx);
606
607 icp_adf_transReleaseHandle(
608 pCompressionService->trans_handle_compression_rx);
609
610 QAT_UTILS_LOG("Failed to get DC RX ring number.\n");
611 return CPA_STATUS_FAIL;
612 }
613
614 /* 2. Allocates memory pools */
615
616 /* Valid initialisation value for a pool ID */
617 pCompressionService->compression_mem_pool = LAC_MEM_POOL_INIT_POOL_ID;
618
619 status = Sal_StringParsing(
620 "Comp",
621 pCompressionService->generic_service_info.instance,
622 "_MemPool",
623 compMemPool);
624 if (CPA_STATUS_SUCCESS != status) {
625 icp_adf_transReleaseHandle(
626 pCompressionService->trans_handle_compression_tx);
627
628 icp_adf_transReleaseHandle(
629 pCompressionService->trans_handle_compression_rx);
630
631 return status;
632 }
633
634 status = Lac_MemPoolCreate(&pCompressionService->compression_mem_pool,
635 compMemPool,
636 (numCompConcurrentReq + 1),
637 sizeof(dc_compression_cookie_t),
638 LAC_64BYTE_ALIGNMENT,
639 CPA_FALSE,
640 pCompressionService->nodeAffinity);
641 if (CPA_STATUS_SUCCESS != status) {
642 icp_adf_transReleaseHandle(
643 pCompressionService->trans_handle_compression_tx);
644
645 icp_adf_transReleaseHandle(
646 pCompressionService->trans_handle_compression_rx);
647
648 return status;
649 }
650
651 /* Init compression statistics */
652 status = dcStatsInit(pCompressionService);
653 if (CPA_STATUS_SUCCESS != status) {
654 Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
655
656 icp_adf_transReleaseHandle(
657 pCompressionService->trans_handle_compression_tx);
658
659 icp_adf_transReleaseHandle(
660 pCompressionService->trans_handle_compression_rx);
661
662 return status;
663 }
664 if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
665 /* Get instance name for stats */
666 instance_name = LAC_OS_MALLOC(ADF_CFG_MAX_VAL_LEN_IN_BYTES);
667 if (NULL == instance_name) {
668 Lac_MemPoolDestroy(
669 pCompressionService->compression_mem_pool);
670
671 icp_adf_transReleaseHandle(
672 pCompressionService->trans_handle_compression_tx);
673
674 icp_adf_transReleaseHandle(
675 pCompressionService->trans_handle_compression_rx);
676
677 return CPA_STATUS_RESOURCE;
678 }
679
680 status = Sal_StringParsing(
681 "Dc",
682 pCompressionService->generic_service_info.instance,
683 "Name",
684 temp_string);
685 if (CPA_STATUS_SUCCESS != status) {
686 Lac_MemPoolDestroy(
687 pCompressionService->compression_mem_pool);
688
689 icp_adf_transReleaseHandle(
690 pCompressionService->trans_handle_compression_tx);
691
692 icp_adf_transReleaseHandle(
693 pCompressionService->trans_handle_compression_rx);
694 LAC_OS_FREE(instance_name);
695 return status;
696 }
697 status = icp_adf_cfgGetParamValue(device,
698 section,
699 temp_string,
700 adfGetParam);
701 if (CPA_STATUS_SUCCESS != status) {
702 QAT_UTILS_LOG("Failed to get %s from configuration.\n",
703 temp_string);
704
705 Lac_MemPoolDestroy(
706 pCompressionService->compression_mem_pool);
707
708 icp_adf_transReleaseHandle(
709 pCompressionService->trans_handle_compression_tx);
710
711 icp_adf_transReleaseHandle(
712 pCompressionService->trans_handle_compression_rx);
713 LAC_OS_FREE(instance_name);
714 return status;
715 }
716
717 snprintf(instance_name,
718 ADF_CFG_MAX_VAL_LEN_IN_BYTES,
719 "%s",
720 adfGetParam);
721
722 pCompressionService->debug_file =
723 LAC_OS_MALLOC(sizeof(debug_file_info_t));
724 if (NULL == pCompressionService->debug_file) {
725 Lac_MemPoolDestroy(
726 pCompressionService->compression_mem_pool);
727
728 icp_adf_transReleaseHandle(
729 pCompressionService->trans_handle_compression_tx);
730
731 icp_adf_transReleaseHandle(
732 pCompressionService->trans_handle_compression_rx);
733 LAC_OS_FREE(instance_name);
734 return CPA_STATUS_RESOURCE;
735 }
736
737 memset(pCompressionService->debug_file,
738 0,
739 sizeof(debug_file_info_t));
740 pCompressionService->debug_file->name = instance_name;
741 pCompressionService->debug_file->seq_read =
742 SalCtrl_CompresionDebug;
743 pCompressionService->debug_file->private_data =
744 pCompressionService;
745 pCompressionService->debug_file->parent =
746 pCompressionService->generic_service_info.debug_parent_dir;
747
748 status = icp_adf_debugAddFile(device,
749 pCompressionService->debug_file);
750 if (CPA_STATUS_SUCCESS != status) {
751 Lac_MemPoolDestroy(
752 pCompressionService->compression_mem_pool);
753
754 icp_adf_transReleaseHandle(
755 pCompressionService->trans_handle_compression_tx);
756
757 icp_adf_transReleaseHandle(
758 pCompressionService->trans_handle_compression_rx);
759 LAC_OS_FREE(instance_name);
760 LAC_OS_FREE(pCompressionService->debug_file);
761 return status;
762 }
763 }
764 pCompressionService->generic_service_info.stats = pStatsCollection;
765 pCompressionService->generic_service_info.state =
766 SAL_SERVICE_STATE_INITIALIZED;
767
768 return status;
769 }
770
771 CpaStatus
SalCtrl_CompressionStart(icp_accel_dev_t * device,sal_service_t * service)772 SalCtrl_CompressionStart(icp_accel_dev_t *device, sal_service_t *service)
773 {
774 CpaStatus status = CPA_STATUS_SUCCESS;
775
776 sal_compression_service_t *pCompressionService =
777 (sal_compression_service_t *)service;
778
779 if (SAL_SERVICE_STATE_INITIALIZED !=
780 pCompressionService->generic_service_info.state) {
781 QAT_UTILS_LOG("Not in the correct state to call start.\n");
782 return CPA_STATUS_FAIL;
783 }
784 /**************************************************************/
785 /* Obtain Extended Features. I.e. Compress And Verify */
786 /**************************************************************/
787 pCompressionService->generic_service_info.dcExtendedFeatures =
788 device->dcExtendedFeatures;
789 pCompressionService->generic_service_info.state =
790 SAL_SERVICE_STATE_RUNNING;
791
792 return status;
793 }
794
795 CpaStatus
SalCtrl_CompressionStop(icp_accel_dev_t * device,sal_service_t * service)796 SalCtrl_CompressionStop(icp_accel_dev_t *device, sal_service_t *service)
797 {
798 sal_compression_service_t *pCompressionService =
799 (sal_compression_service_t *)service;
800
801 if (SAL_SERVICE_STATE_RUNNING !=
802 pCompressionService->generic_service_info.state) {
803 QAT_UTILS_LOG("Not in the correct state to call stop.\n");
804 return CPA_STATUS_FAIL;
805 }
806
807 if (icp_adf_is_dev_in_reset(device)) {
808 pCompressionService->generic_service_info.state =
809 SAL_SERVICE_STATE_RESTARTING;
810 return CPA_STATUS_SUCCESS;
811 }
812
813 pCompressionService->generic_service_info.state =
814 SAL_SERVICE_STATE_SHUTTING_DOWN;
815 return CPA_STATUS_RETRY;
816 }
817
818 CpaStatus
SalCtrl_CompressionShutdown(icp_accel_dev_t * device,sal_service_t * service)819 SalCtrl_CompressionShutdown(icp_accel_dev_t *device, sal_service_t *service)
820 {
821 CpaStatus status = CPA_STATUS_SUCCESS;
822
823 sal_compression_service_t *pCompressionService =
824 (sal_compression_service_t *)service;
825 sal_statistics_collection_t *pStatsCollection =
826 (sal_statistics_collection_t *)device->pQatStats;
827
828 if ((SAL_SERVICE_STATE_INITIALIZED !=
829 pCompressionService->generic_service_info.state) &&
830 (SAL_SERVICE_STATE_SHUTTING_DOWN !=
831 pCompressionService->generic_service_info.state) &&
832 (SAL_SERVICE_STATE_RESTARTING !=
833 pCompressionService->generic_service_info.state)) {
834 QAT_UTILS_LOG("Not in the correct state to call shutdown.\n");
835 return CPA_STATUS_FAIL;
836 }
837
838 Lac_MemPoolDestroy(pCompressionService->compression_mem_pool);
839
840 status = icp_adf_transReleaseHandle(
841 pCompressionService->trans_handle_compression_tx);
842 LAC_CHECK_STATUS(status);
843
844 status = icp_adf_transReleaseHandle(
845 pCompressionService->trans_handle_compression_rx);
846 LAC_CHECK_STATUS(status);
847
848 if (CPA_TRUE == pStatsCollection->bDcStatsEnabled) {
849 /* Clean stats */
850 if (NULL != pCompressionService->debug_file) {
851 icp_adf_debugRemoveFile(
852 pCompressionService->debug_file);
853 LAC_OS_FREE(pCompressionService->debug_file->name);
854 LAC_OS_FREE(pCompressionService->debug_file);
855 pCompressionService->debug_file = NULL;
856 }
857 }
858 pCompressionService->generic_service_info.stats = NULL;
859 dcStatsFree(pCompressionService);
860
861 if (icp_adf_is_dev_in_reset(device)) {
862 pCompressionService->generic_service_info.state =
863 SAL_SERVICE_STATE_RESTARTING;
864 return CPA_STATUS_SUCCESS;
865 }
866 pCompressionService->generic_service_info.state =
867 SAL_SERVICE_STATE_SHUTDOWN;
868 return status;
869 }
870
871 CpaStatus
cpaDcGetStatusText(const CpaInstanceHandle dcInstance,const CpaStatus errStatus,Cpa8S * pStatusText)872 cpaDcGetStatusText(const CpaInstanceHandle dcInstance,
873 const CpaStatus errStatus,
874 Cpa8S *pStatusText)
875 {
876 CpaStatus status = CPA_STATUS_SUCCESS;
877
878 LAC_CHECK_NULL_PARAM(pStatusText);
879
880 switch (errStatus) {
881 case CPA_STATUS_SUCCESS:
882 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_SUCCESS);
883 break;
884 case CPA_STATUS_FAIL:
885 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FAIL);
886 break;
887 case CPA_STATUS_RETRY:
888 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RETRY);
889 break;
890 case CPA_STATUS_RESOURCE:
891 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_RESOURCE);
892 break;
893 case CPA_STATUS_INVALID_PARAM:
894 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_INVALID_PARAM);
895 break;
896 case CPA_STATUS_FATAL:
897 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_FATAL);
898 break;
899 case CPA_STATUS_UNSUPPORTED:
900 LAC_COPY_STRING(pStatusText, CPA_STATUS_STR_UNSUPPORTED);
901 break;
902 default:
903 status = CPA_STATUS_INVALID_PARAM;
904 break;
905 }
906
907 return status;
908 }
909
910 CpaStatus
cpaDcGetNumIntermediateBuffers(CpaInstanceHandle dcInstance,Cpa16U * pNumBuffers)911 cpaDcGetNumIntermediateBuffers(CpaInstanceHandle dcInstance,
912 Cpa16U *pNumBuffers)
913 {
914 CpaInstanceHandle insHandle = NULL;
915 sal_compression_service_t *pService = NULL;
916
917 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
918 insHandle = dcGetFirstHandle();
919 } else {
920 insHandle = dcInstance;
921 }
922
923 LAC_CHECK_NULL_PARAM(insHandle);
924 LAC_CHECK_NULL_PARAM(pNumBuffers);
925
926 pService = (sal_compression_service_t *)insHandle;
927 *pNumBuffers = pService->numInterBuffs;
928
929 return CPA_STATUS_SUCCESS;
930 }
931
932 CpaStatus
cpaDcStartInstance(CpaInstanceHandle instanceHandle,Cpa16U numBuffers,CpaBufferList ** pIntermediateBufferPtrsArray)933 cpaDcStartInstance(CpaInstanceHandle instanceHandle,
934 Cpa16U numBuffers,
935 CpaBufferList **pIntermediateBufferPtrsArray)
936 {
937 icp_qat_addr_width_t *pInterBuffPtrsArray = NULL;
938 icp_qat_addr_width_t pArrayBufferListDescPhyAddr = 0;
939 icp_qat_addr_width_t bufListDescPhyAddr;
940 icp_qat_addr_width_t bufListAlignedPhyAddr;
941 CpaFlatBuffer *pClientCurrFlatBuffer = NULL;
942 icp_buffer_list_desc_t *pBufferListDesc = NULL;
943 icp_flat_buffer_desc_t *pCurrFlatBufDesc = NULL;
944 CpaInstanceInfo2 info = { 0 };
945 icp_accel_dev_t *dev = NULL;
946 CpaStatus status = CPA_STATUS_SUCCESS;
947 sal_compression_service_t *pService = NULL;
948 CpaInstanceHandle insHandle = NULL;
949 Cpa16U bufferIndex = 0;
950 Cpa32U numFlatBuffers = 0;
951 Cpa64U clientListSize = 0;
952 CpaBufferList *pClientCurrentIntermediateBuffer = NULL;
953 Cpa32U bufferIndex2 = 0;
954 CpaBufferList **pTempIntermediateBufferPtrsArray;
955 Cpa64U lastClientListSize = 0;
956
957 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
958 insHandle = dcGetFirstHandle();
959 } else {
960 insHandle = instanceHandle;
961 }
962 LAC_CHECK_NULL_PARAM(insHandle);
963
964 status = cpaDcInstanceGetInfo2(insHandle, &info);
965 if (CPA_STATUS_SUCCESS != status) {
966 QAT_UTILS_LOG("Can not get instance info.\n");
967 return status;
968 }
969
970 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
971 if (NULL == dev) {
972 QAT_UTILS_LOG("Can not find device for the instance\n");
973 return CPA_STATUS_FAIL;
974 }
975
976 if (NULL == pIntermediateBufferPtrsArray) {
977 /* Increment dev ref counter and return - DRAM is not used */
978 icp_qa_dev_get(dev);
979 return CPA_STATUS_SUCCESS;
980 }
981
982 if (0 == numBuffers) {
983 /* Increment dev ref counter and return - DRAM is not used */
984 icp_qa_dev_get(dev);
985 return CPA_STATUS_SUCCESS;
986 }
987
988 pService = (sal_compression_service_t *)insHandle;
989
990 LAC_CHECK_NULL_PARAM(insHandle);
991
992 if ((numBuffers > 0) && (NULL == pIntermediateBufferPtrsArray)) {
993 QAT_UTILS_LOG("Invalid Intermediate Buffers Array pointer\n");
994 return CPA_STATUS_INVALID_PARAM;
995 }
996
997 /* Check number of intermediate buffers allocated by user */
998 if ((pService->numInterBuffs != numBuffers)) {
999 QAT_UTILS_LOG("Invalid number of buffers\n");
1000 return CPA_STATUS_INVALID_PARAM;
1001 }
1002
1003 pTempIntermediateBufferPtrsArray = pIntermediateBufferPtrsArray;
1004 for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
1005 if (NULL == *pTempIntermediateBufferPtrsArray) {
1006 QAT_UTILS_LOG(
1007 "Intermediate Buffer - Invalid Buffer List pointer\n");
1008 return CPA_STATUS_INVALID_PARAM;
1009 }
1010
1011 if (NULL == (*pTempIntermediateBufferPtrsArray)->pBuffers) {
1012 QAT_UTILS_LOG(
1013 "Intermediate Buffer - Invalid Flat Buffer descriptor pointer\n");
1014 return CPA_STATUS_INVALID_PARAM;
1015 }
1016
1017 if (NULL ==
1018 (*pTempIntermediateBufferPtrsArray)->pPrivateMetaData) {
1019 QAT_UTILS_LOG(
1020 "Intermediate Buffer - Invalid Private MetaData descriptor pointer\n");
1021 return CPA_STATUS_INVALID_PARAM;
1022 }
1023
1024 clientListSize = 0;
1025 for (bufferIndex2 = 0; bufferIndex2 <
1026 (*pTempIntermediateBufferPtrsArray)->numBuffers;
1027 bufferIndex2++) {
1028
1029 if ((0 !=
1030 (*pTempIntermediateBufferPtrsArray)
1031 ->pBuffers[bufferIndex2]
1032 .dataLenInBytes) &&
1033 NULL ==
1034 (*pTempIntermediateBufferPtrsArray)
1035 ->pBuffers[bufferIndex2]
1036 .pData) {
1037 QAT_UTILS_LOG(
1038 "Intermediate Buffer - Invalid Flat Buffer pointer\n");
1039 return CPA_STATUS_INVALID_PARAM;
1040 }
1041
1042 clientListSize += (*pTempIntermediateBufferPtrsArray)
1043 ->pBuffers[bufferIndex2]
1044 .dataLenInBytes;
1045 }
1046
1047 if (bufferIndex != 0) {
1048 if (lastClientListSize != clientListSize) {
1049 QAT_UTILS_LOG(
1050 "SGLs have to be of the same size.\n");
1051 return CPA_STATUS_INVALID_PARAM;
1052 }
1053 } else {
1054 lastClientListSize = clientListSize;
1055 }
1056 pTempIntermediateBufferPtrsArray++;
1057 }
1058
1059 /* Allocate array of physical pointers to icp_buffer_list_desc_t */
1060 status = LAC_OS_CAMALLOC(&pInterBuffPtrsArray,
1061 (numBuffers * sizeof(icp_qat_addr_width_t)),
1062 LAC_64BYTE_ALIGNMENT,
1063 pService->nodeAffinity);
1064 if (CPA_STATUS_SUCCESS != status) {
1065 QAT_UTILS_LOG("Can not allocate Intermediate Buffers array.\n");
1066 return status;
1067 }
1068
1069 /* Get physical address of the intermediate buffer pointers array */
1070 pArrayBufferListDescPhyAddr = LAC_MEM_CAST_PTR_TO_UINT64(
1071 LAC_OS_VIRT_TO_PHYS_INTERNAL(pInterBuffPtrsArray));
1072
1073 pService->pInterBuffPtrsArray = pInterBuffPtrsArray;
1074 pService->pInterBuffPtrsArrayPhyAddr = pArrayBufferListDescPhyAddr;
1075
1076 /* Get the full size of the buffer list */
1077 /* Assumption: all the SGLs allocated by the user have the same size */
1078 clientListSize = 0;
1079 for (bufferIndex = 0;
1080 bufferIndex < (*pIntermediateBufferPtrsArray)->numBuffers;
1081 bufferIndex++) {
1082 clientListSize += ((*pIntermediateBufferPtrsArray)
1083 ->pBuffers[bufferIndex]
1084 .dataLenInBytes);
1085 }
1086 pService->minInterBuffSizeInBytes = clientListSize;
1087
1088 for (bufferIndex = 0; bufferIndex < numBuffers; bufferIndex++) {
1089
1090 /* Get pointer to the client Intermediate Buffer List
1091 * (CpaBufferList) */
1092 pClientCurrentIntermediateBuffer =
1093 *pIntermediateBufferPtrsArray;
1094
1095 /* Get number of flat buffers in the buffer list */
1096 numFlatBuffers = pClientCurrentIntermediateBuffer->numBuffers;
1097
1098 /* Get pointer to the client array of CpaFlatBuffers */
1099 pClientCurrFlatBuffer =
1100 pClientCurrentIntermediateBuffer->pBuffers;
1101
1102 /* Calculate Physical address of current private SGL */
1103 bufListDescPhyAddr = LAC_OS_VIRT_TO_PHYS_EXTERNAL(
1104 (*pService),
1105 pClientCurrentIntermediateBuffer->pPrivateMetaData);
1106 if (bufListDescPhyAddr == 0) {
1107 QAT_UTILS_LOG(
1108 "Unable to get the physical address of the metadata.\n");
1109 return CPA_STATUS_FAIL;
1110 }
1111
1112 /* Align SGL physical address */
1113 bufListAlignedPhyAddr =
1114 LAC_ALIGN_POW2_ROUNDUP(bufListDescPhyAddr,
1115 ICP_DESCRIPTOR_ALIGNMENT_BYTES);
1116
1117 /* Set physical address of the Intermediate Buffer SGL in the
1118 * SGLs array
1119 */
1120 *pInterBuffPtrsArray =
1121 LAC_MEM_CAST_PTR_TO_UINT64(bufListAlignedPhyAddr);
1122
1123 /* Calculate (virtual) offset to the buffer list descriptor */
1124 pBufferListDesc =
1125 (icp_buffer_list_desc_t
1126 *)((LAC_ARCH_UINT)pClientCurrentIntermediateBuffer
1127 ->pPrivateMetaData +
1128 (LAC_ARCH_UINT)(bufListAlignedPhyAddr -
1129 bufListDescPhyAddr));
1130
1131 /* Set number of flat buffers in the physical Buffer List
1132 * descriptor */
1133 pBufferListDesc->numBuffers = numFlatBuffers;
1134
1135 /* Go past the Buffer List descriptor to the list of buffer
1136 * descriptors
1137 */
1138 pCurrFlatBufDesc =
1139 (icp_flat_buffer_desc_t *)((pBufferListDesc->phyBuffers));
1140
1141 /* Loop for each flat buffer in the SGL */
1142 while (0 != numFlatBuffers) {
1143 /* Set length of the current flat buffer */
1144 pCurrFlatBufDesc->dataLenInBytes =
1145 pClientCurrFlatBuffer->dataLenInBytes;
1146
1147 /* Set physical address of the flat buffer */
1148 pCurrFlatBufDesc->phyBuffer =
1149 LAC_MEM_CAST_PTR_TO_UINT64(
1150 LAC_OS_VIRT_TO_PHYS_EXTERNAL(
1151 (*pService), pClientCurrFlatBuffer->pData));
1152
1153 if (pCurrFlatBufDesc->phyBuffer == 0) {
1154 QAT_UTILS_LOG(
1155 "Unable to get the physical address of the flat buffer.\n");
1156 return CPA_STATUS_FAIL;
1157 }
1158
1159 pCurrFlatBufDesc++;
1160 pClientCurrFlatBuffer++;
1161 numFlatBuffers--;
1162 }
1163 pIntermediateBufferPtrsArray++;
1164 pInterBuffPtrsArray++;
1165 }
1166
1167 pService->generic_service_info.isInstanceStarted = CPA_TRUE;
1168
1169 /* Increment dev ref counter */
1170 icp_qa_dev_get(dev);
1171 return CPA_STATUS_SUCCESS;
1172 }
1173
1174 CpaStatus
cpaDcStopInstance(CpaInstanceHandle instanceHandle)1175 cpaDcStopInstance(CpaInstanceHandle instanceHandle)
1176 {
1177 CpaInstanceHandle insHandle = NULL;
1178 CpaInstanceInfo2 info = { 0 };
1179 icp_accel_dev_t *dev = NULL;
1180 CpaStatus status = CPA_STATUS_SUCCESS;
1181 sal_compression_service_t *pService = NULL;
1182
1183 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1184 insHandle = dcGetFirstHandle();
1185 } else {
1186 insHandle = instanceHandle;
1187 }
1188
1189 LAC_CHECK_NULL_PARAM(insHandle);
1190 pService = (sal_compression_service_t *)insHandle;
1191
1192 /* Free Intermediate Buffer Pointers Array */
1193 if (pService->pInterBuffPtrsArray != NULL) {
1194 LAC_OS_CAFREE(pService->pInterBuffPtrsArray);
1195 pService->pInterBuffPtrsArray = 0;
1196 }
1197
1198 pService->pInterBuffPtrsArrayPhyAddr = 0;
1199
1200 status = cpaDcInstanceGetInfo2(insHandle, &info);
1201 if (CPA_STATUS_SUCCESS != status) {
1202 QAT_UTILS_LOG("Can not get instance info.\n");
1203 return status;
1204 }
1205 dev = icp_adf_getAccelDevByAccelId(info.physInstId.packageId);
1206 if (NULL == dev) {
1207 QAT_UTILS_LOG("Can not find device for the instance.\n");
1208 return CPA_STATUS_FAIL;
1209 }
1210
1211 pService->generic_service_info.isInstanceStarted = CPA_FALSE;
1212
1213 /* Decrement dev ref counter */
1214 icp_qa_dev_put(dev);
1215 return CPA_STATUS_SUCCESS;
1216 }
1217
1218 CpaStatus
cpaDcGetNumInstances(Cpa16U * pNumInstances)1219 cpaDcGetNumInstances(Cpa16U *pNumInstances)
1220 {
1221 CpaStatus status = CPA_STATUS_SUCCESS;
1222 icp_accel_dev_t **pAdfInsts = NULL;
1223 icp_accel_dev_t *dev_addr = NULL;
1224 sal_t *base_addr = NULL;
1225 sal_list_t *list_temp = NULL;
1226 Cpa16U num_accel_dev = 0;
1227 Cpa16U num = 0;
1228 Cpa16U i = 0;
1229
1230 LAC_CHECK_NULL_PARAM(pNumInstances);
1231
1232 /* Get the number of accel_dev in the system */
1233 status = icp_amgr_getNumInstances(&num_accel_dev);
1234 LAC_CHECK_STATUS(status);
1235
1236 /* Allocate memory to store addr of accel_devs */
1237 pAdfInsts =
1238 malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
1239 num_accel_dev = 0;
1240
1241 /* Get ADF to return accel_devs with dc enabled */
1242 status = icp_amgr_getAllAccelDevByCapabilities(
1243 ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
1244 if (CPA_STATUS_SUCCESS == status) {
1245 for (i = 0; i < num_accel_dev; i++) {
1246 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1247 if (NULL != dev_addr) {
1248 base_addr = dev_addr->pSalHandle;
1249 if (NULL != base_addr) {
1250 list_temp =
1251 base_addr->compression_services;
1252 while (NULL != list_temp) {
1253 num++;
1254 list_temp =
1255 SalList_next(list_temp);
1256 }
1257 }
1258 }
1259 }
1260
1261 *pNumInstances = num;
1262 }
1263
1264 free(pAdfInsts, M_QAT);
1265
1266 return status;
1267 }
1268
1269 CpaStatus
cpaDcGetInstances(Cpa16U numInstances,CpaInstanceHandle * dcInstances)1270 cpaDcGetInstances(Cpa16U numInstances, CpaInstanceHandle *dcInstances)
1271 {
1272 CpaStatus status = CPA_STATUS_SUCCESS;
1273 icp_accel_dev_t **pAdfInsts = NULL;
1274 icp_accel_dev_t *dev_addr = NULL;
1275 sal_t *base_addr = NULL;
1276 sal_list_t *list_temp = NULL;
1277 Cpa16U num_accel_dev = 0;
1278 Cpa16U index = 0;
1279 Cpa16U i = 0;
1280
1281 LAC_CHECK_NULL_PARAM(dcInstances);
1282 if (0 == numInstances) {
1283 QAT_UTILS_LOG("numInstances is 0.\n");
1284 return CPA_STATUS_INVALID_PARAM;
1285 }
1286
1287 /* Get the number of accel_dev in the system */
1288 status = icp_amgr_getNumInstances(&num_accel_dev);
1289 LAC_CHECK_STATUS(status);
1290
1291 /* Allocate memory to store addr of accel_devs */
1292 pAdfInsts =
1293 malloc(num_accel_dev * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);
1294
1295 num_accel_dev = 0;
1296 /* Get ADF to return accel_devs with dc enabled */
1297 status = icp_amgr_getAllAccelDevByCapabilities(
1298 ICP_ACCEL_CAPABILITIES_COMPRESSION, pAdfInsts, &num_accel_dev);
1299
1300 if (CPA_STATUS_SUCCESS == status) {
1301 /* First check the number of instances in the system */
1302 for (i = 0; i < num_accel_dev; i++) {
1303 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1304 if (NULL != dev_addr) {
1305 base_addr = dev_addr->pSalHandle;
1306 if (NULL != base_addr) {
1307 list_temp =
1308 base_addr->compression_services;
1309 while (NULL != list_temp) {
1310 if (index >
1311 (numInstances - 1)) {
1312 break;
1313 }
1314
1315 dcInstances[index] =
1316 SalList_getObject(
1317 list_temp);
1318 list_temp =
1319 SalList_next(list_temp);
1320 index++;
1321 }
1322 }
1323 }
1324 }
1325
1326 if (numInstances > index) {
1327 QAT_UTILS_LOG("Only %d dc instances available.\n",
1328 index);
1329 status = CPA_STATUS_RESOURCE;
1330 }
1331 }
1332
1333 if (CPA_STATUS_SUCCESS == status) {
1334 index = 0;
1335 for (i = 0; i < num_accel_dev; i++) {
1336 dev_addr = (icp_accel_dev_t *)pAdfInsts[i];
1337 /* Note dev_addr cannot be NULL here as numInstances=0
1338 is not valid and if dev_addr=NULL then index=0 (which
1339 is less than numInstances and status is set to
1340 _RESOURCE
1341 above */
1342 base_addr = dev_addr->pSalHandle;
1343 if (NULL != base_addr) {
1344 list_temp = base_addr->compression_services;
1345 while (NULL != list_temp) {
1346 if (index > (numInstances - 1)) {
1347 break;
1348 }
1349
1350 dcInstances[index] =
1351 SalList_getObject(list_temp);
1352 list_temp = SalList_next(list_temp);
1353 index++;
1354 }
1355 }
1356 }
1357 }
1358
1359 free(pAdfInsts, M_QAT);
1360
1361 return status;
1362 }
1363
1364 CpaStatus
cpaDcInstanceGetInfo2(const CpaInstanceHandle instanceHandle,CpaInstanceInfo2 * pInstanceInfo2)1365 cpaDcInstanceGetInfo2(const CpaInstanceHandle instanceHandle,
1366 CpaInstanceInfo2 *pInstanceInfo2)
1367 {
1368 sal_compression_service_t *pCompressionService = NULL;
1369 CpaInstanceHandle insHandle = NULL;
1370 icp_accel_dev_t *dev = NULL;
1371 CpaStatus status = CPA_STATUS_SUCCESS;
1372 char keyStr[ADF_CFG_MAX_KEY_LEN_IN_BYTES] = { 0 };
1373 char valStr[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
1374 char *section = DYN_SEC;
1375
1376 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1377 insHandle = dcGetFirstHandle();
1378 } else {
1379 insHandle = instanceHandle;
1380 }
1381
1382 LAC_CHECK_NULL_PARAM(insHandle);
1383 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1384 LAC_CHECK_NULL_PARAM(pInstanceInfo2);
1385
1386 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1387 pInstanceInfo2->accelerationServiceType =
1388 CPA_ACC_SVC_TYPE_DATA_COMPRESSION;
1389
1390 snprintf((char *)pInstanceInfo2->vendorName,
1391 CPA_INST_VENDOR_NAME_SIZE,
1392 "%s",
1393 SAL_INFO2_VENDOR_NAME);
1394 pInstanceInfo2->vendorName[CPA_INST_VENDOR_NAME_SIZE - 1] = '\0';
1395
1396 snprintf((char *)pInstanceInfo2->swVersion,
1397 CPA_INST_SW_VERSION_SIZE,
1398 "Version %d.%d",
1399 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER,
1400 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER);
1401 pInstanceInfo2->swVersion[CPA_INST_SW_VERSION_SIZE - 1] = '\0';
1402
1403 /* Note we can safely read the contents of the compression service
1404 instance
1405 here because icp_amgr_getAccelDevByCapabilities() only returns devs
1406 that have started */
1407 pCompressionService = (sal_compression_service_t *)insHandle;
1408 pInstanceInfo2->physInstId.packageId = pCompressionService->pkgID;
1409 pInstanceInfo2->physInstId.acceleratorId =
1410 pCompressionService->acceleratorNum;
1411 pInstanceInfo2->physInstId.executionEngineId = 0;
1412 pInstanceInfo2->physInstId.busAddress =
1413 icp_adf_get_busAddress(pInstanceInfo2->physInstId.packageId);
1414
1415 /* set coreAffinity to zero before use */
1416 LAC_OS_BZERO(pInstanceInfo2->coreAffinity,
1417 sizeof(pInstanceInfo2->coreAffinity));
1418 CPA_BITMAP_BIT_SET(pInstanceInfo2->coreAffinity,
1419 pCompressionService->coreAffinity);
1420
1421 pInstanceInfo2->nodeAffinity = pCompressionService->nodeAffinity;
1422
1423 if (CPA_TRUE ==
1424 pCompressionService->generic_service_info.isInstanceStarted) {
1425 pInstanceInfo2->operState = CPA_OPER_STATE_UP;
1426 } else {
1427 pInstanceInfo2->operState = CPA_OPER_STATE_DOWN;
1428 }
1429
1430 pInstanceInfo2->requiresPhysicallyContiguousMemory = CPA_TRUE;
1431
1432 if (SAL_RESP_POLL_CFG_FILE == pCompressionService->isPolled) {
1433 pInstanceInfo2->isPolled = CPA_TRUE;
1434 } else {
1435 pInstanceInfo2->isPolled = CPA_FALSE;
1436 }
1437
1438 pInstanceInfo2->isOffloaded = CPA_TRUE;
1439 /* Get the instance name and part name from the config file */
1440 dev = icp_adf_getAccelDevByAccelId(pCompressionService->pkgID);
1441 if (NULL == dev) {
1442 QAT_UTILS_LOG("Can not find device for the instance.\n");
1443 LAC_OS_BZERO(pInstanceInfo2, sizeof(CpaInstanceInfo2));
1444 return CPA_STATUS_FAIL;
1445 }
1446 snprintf((char *)pInstanceInfo2->partName,
1447 CPA_INST_PART_NAME_SIZE,
1448 SAL_INFO2_PART_NAME,
1449 dev->deviceName);
1450 pInstanceInfo2->partName[CPA_INST_PART_NAME_SIZE - 1] = '\0';
1451
1452 if (CPA_FALSE == pCompressionService->generic_service_info.is_dyn) {
1453 section = icpGetProcessName();
1454 }
1455
1456 status = Sal_StringParsing(
1457 "Dc",
1458 pCompressionService->generic_service_info.instance,
1459 "Name",
1460 keyStr);
1461 LAC_CHECK_STATUS(status);
1462 status = icp_adf_cfgGetParamValue(dev, section, keyStr, valStr);
1463 LAC_CHECK_STATUS(status);
1464 strncpy((char *)pInstanceInfo2->instName,
1465 valStr,
1466 sizeof(pInstanceInfo2->instName) - 1);
1467 pInstanceInfo2->instName[CPA_INST_NAME_SIZE - 1] = '\0';
1468
1469 #if __GNUC__ >= 7
1470 #pragma GCC diagnostic push
1471 #pragma GCC diagnostic ignored "-Wformat-truncation"
1472 #endif
1473 snprintf((char *)pInstanceInfo2->instID,
1474 CPA_INST_ID_SIZE,
1475 "%s_%s",
1476 section,
1477 valStr);
1478 #if __GNUC__ >= 7
1479 #pragma GCC diagnostic pop
1480 #endif
1481
1482 return CPA_STATUS_SUCCESS;
1483 }
1484
1485 CpaStatus
cpaDcQueryCapabilities(CpaInstanceHandle dcInstance,CpaDcInstanceCapabilities * pInstanceCapabilities)1486 cpaDcQueryCapabilities(CpaInstanceHandle dcInstance,
1487 CpaDcInstanceCapabilities *pInstanceCapabilities)
1488 {
1489 CpaInstanceHandle insHandle = NULL;
1490 sal_compression_service_t *pService = NULL;
1491 Cpa32U capabilitiesMask = 0;
1492 dc_extd_ftrs_t *pExtendedFtrs = NULL;
1493
1494 if (CPA_INSTANCE_HANDLE_SINGLE == dcInstance) {
1495 insHandle = dcGetFirstHandle();
1496 if (NULL == insHandle) {
1497 QAT_UTILS_LOG("Can not get the instance.\n");
1498 return CPA_STATUS_FAIL;
1499 }
1500 } else {
1501 insHandle = dcInstance;
1502 }
1503
1504 pService = (sal_compression_service_t *)insHandle;
1505
1506 LAC_CHECK_NULL_PARAM(insHandle);
1507 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1508 LAC_CHECK_NULL_PARAM(pInstanceCapabilities);
1509
1510 memset(pInstanceCapabilities, 0, sizeof(CpaDcInstanceCapabilities));
1511
1512 capabilitiesMask = pService->generic_service_info.capabilitiesMask;
1513
1514 /* Set compression capabilities */
1515 if (capabilitiesMask & ICP_ACCEL_CAPABILITIES_CNV_INTEGRITY) {
1516 pInstanceCapabilities->integrityCrcs = CPA_TRUE;
1517 }
1518
1519 pInstanceCapabilities->endOfLastBlock = CPA_TRUE;
1520 pInstanceCapabilities->statefulDeflateCompression = CPA_FALSE;
1521 pInstanceCapabilities->statefulDeflateDecompression = CPA_TRUE;
1522 pInstanceCapabilities->statelessDeflateCompression = CPA_TRUE;
1523 pInstanceCapabilities->statelessDeflateDecompression = CPA_TRUE;
1524 pInstanceCapabilities->checksumCRC32 = CPA_TRUE;
1525 pInstanceCapabilities->checksumAdler32 = CPA_TRUE;
1526 pInstanceCapabilities->dynamicHuffman = CPA_TRUE;
1527 pInstanceCapabilities->precompiledHuffman = CPA_FALSE;
1528 pInstanceCapabilities->dynamicHuffmanBufferReq = CPA_TRUE;
1529 pInstanceCapabilities->autoSelectBestHuffmanTree = CPA_TRUE;
1530
1531 pInstanceCapabilities->validWindowSizeMaskCompression =
1532 pService->comp_device_data.windowSizeMask;
1533 pInstanceCapabilities->validWindowSizeMaskDecompression =
1534 pService->comp_device_data.windowSizeMask;
1535 pExtendedFtrs = (dc_extd_ftrs_t *)&(
1536 ((sal_service_t *)insHandle)->dcExtendedFeatures);
1537 pInstanceCapabilities->batchAndPack = CPA_FALSE;
1538 pInstanceCapabilities->compressAndVerify =
1539 (CpaBoolean)pExtendedFtrs->is_cnv;
1540 pInstanceCapabilities->compressAndVerifyStrict = CPA_TRUE;
1541 pInstanceCapabilities->compressAndVerifyAndRecover =
1542 (CpaBoolean)pExtendedFtrs->is_cnvnr;
1543 return CPA_STATUS_SUCCESS;
1544 }
1545
1546 CpaStatus
cpaDcSetAddressTranslation(const CpaInstanceHandle instanceHandle,CpaVirtualToPhysical virtual2Physical)1547 cpaDcSetAddressTranslation(const CpaInstanceHandle instanceHandle,
1548 CpaVirtualToPhysical virtual2Physical)
1549 {
1550 sal_service_t *pService = NULL;
1551 CpaInstanceHandle insHandle = NULL;
1552
1553 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle) {
1554 insHandle = dcGetFirstHandle();
1555 } else {
1556 insHandle = instanceHandle;
1557 }
1558
1559 LAC_CHECK_NULL_PARAM(insHandle);
1560 SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
1561 LAC_CHECK_NULL_PARAM(virtual2Physical);
1562
1563 pService = (sal_service_t *)insHandle;
1564
1565 pService->virt2PhysClient = virtual2Physical;
1566
1567 return CPA_STATUS_SUCCESS;
1568 }
1569
1570 /**
1571 ******************************************************************************
1572 * @ingroup cpaDcCommon
1573 * Data compression specific polling function which polls a DC instance.
1574 *****************************************************************************/
1575
1576 CpaStatus
icp_sal_DcPollInstance(CpaInstanceHandle instanceHandle_in,Cpa32U response_quota)1577 icp_sal_DcPollInstance(CpaInstanceHandle instanceHandle_in,
1578 Cpa32U response_quota)
1579 {
1580 CpaStatus status = CPA_STATUS_SUCCESS;
1581 sal_compression_service_t *dc_handle = NULL;
1582 sal_service_t *gen_handle = NULL;
1583 icp_comms_trans_handle trans_hndTable[DC_NUM_RX_RINGS];
1584
1585 if (CPA_INSTANCE_HANDLE_SINGLE == instanceHandle_in) {
1586 dc_handle = (sal_compression_service_t *)dcGetFirstHandle();
1587 } else {
1588 dc_handle = (sal_compression_service_t *)instanceHandle_in;
1589 }
1590
1591 LAC_CHECK_NULL_PARAM(dc_handle);
1592 SAL_RUNNING_CHECK(dc_handle);
1593
1594 gen_handle = &(dc_handle->generic_service_info);
1595 if (SAL_SERVICE_TYPE_COMPRESSION != gen_handle->type) {
1596 QAT_UTILS_LOG("Instance handle type is incorrect.\n");
1597 return CPA_STATUS_FAIL;
1598 }
1599
1600 /*
1601 * From the instanceHandle we must get the trans_handle and send
1602 * down to adf for polling.
1603 * Populate our trans handle table with the appropriate handles.
1604 */
1605 trans_hndTable[0] = dc_handle->trans_handle_compression_rx;
1606
1607 /* Call adf to do the polling. */
1608 status = icp_adf_pollInstance(trans_hndTable,
1609 DC_NUM_RX_RINGS,
1610 response_quota);
1611 return status;
1612 }
1613
1614 /**
1615 ******************************************************************************
1616 * @ingroup cpaDcCommon
1617 *****************************************************************************/
1618 CpaStatus
cpaDcInstanceSetNotificationCb(const CpaInstanceHandle instanceHandle,const CpaDcInstanceNotificationCbFunc pInstanceNotificationCb,void * pCallbackTag)1619 cpaDcInstanceSetNotificationCb(
1620 const CpaInstanceHandle instanceHandle,
1621 const CpaDcInstanceNotificationCbFunc pInstanceNotificationCb,
1622 void *pCallbackTag)
1623 {
1624 CpaStatus status = CPA_STATUS_SUCCESS;
1625 sal_service_t *gen_handle = instanceHandle;
1626
1627 LAC_CHECK_NULL_PARAM(gen_handle);
1628 gen_handle->notification_cb = pInstanceNotificationCb;
1629 gen_handle->cb_tag = pCallbackTag;
1630 return status;
1631 }
1632
1633 CpaInstanceHandle
dcGetFirstHandle(void)1634 dcGetFirstHandle(void)
1635 {
1636 CpaStatus status = CPA_STATUS_SUCCESS;
1637 static icp_accel_dev_t *adfInsts[ADF_MAX_DEVICES] = { 0 };
1638 CpaInstanceHandle dcInst = NULL;
1639 icp_accel_dev_t *dev_addr = NULL;
1640 sal_t *base_addr = NULL;
1641 sal_list_t *list_temp = NULL;
1642 Cpa16U i, num_dc = 0;
1643
1644 /* Only need 1 dev with compression enabled - so check all devices */
1645 status = icp_amgr_getAllAccelDevByCapabilities(
1646 ICP_ACCEL_CAPABILITIES_COMPRESSION, adfInsts, &num_dc);
1647 if ((0 == num_dc) || (CPA_STATUS_SUCCESS != status)) {
1648 QAT_UTILS_LOG(
1649 "No compression devices enabled in the system.\n");
1650 return dcInst;
1651 }
1652
1653 for (i = 0; i < num_dc; i++) {
1654 dev_addr = (icp_accel_dev_t *)adfInsts[i];
1655 if (NULL != dev_addr) {
1656 base_addr = dev_addr->pSalHandle;
1657 if (NULL != base_addr) {
1658 list_temp = base_addr->compression_services;
1659 if (NULL != list_temp) {
1660 dcInst = SalList_getObject(list_temp);
1661 break;
1662 }
1663 }
1664 }
1665 }
1666 return dcInst;
1667 }
1668