1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /* Copyright(c) 2007-2022 Intel Corporation */
3 /**
4 *****************************************************************************
5 * @file lac_common.h Common macros
6 *
7 * @defgroup Lac Look Aside Crypto LLD Doc
8 *
9 *****************************************************************************/
10
11 /**
12 *****************************************************************************
13 * @defgroup LacCommon LAC Common
14 * Common code for Lac which includes init/shutdown, memory, logging and
15 * hooks.
16 *
17 * @ingroup Lac
18 *
19 *****************************************************************************/
20
21 /***************************************************************************/
22
23 #ifndef LAC_COMMON_H
24 #define LAC_COMMON_H
25
26 /*
27 ******************************************************************************
28 * Include public/global header files
29 ******************************************************************************
30 */
31
32 #include "cpa.h"
33 #include "qat_utils.h"
34 #include "cpa_cy_common.h"
35 #include "icp_adf_init.h"
36
37 #define LAC_ARCH_UINT uintptr_t
38 #define LAC_ARCH_INT intptr_t
39
40 /*
41 *****************************************************************************
42 * Max range values for some primitive param checking
43 *****************************************************************************
44 */
45
46 /**< Maximum number of instances */
47 #define SAL_MAX_NUM_INSTANCES_PER_DEV 512
48
49 #define SAL_DEFAULT_RING_SIZE 256
50 /**< Default ring size */
51
52 #define SAL_64_CONCURR_REQUESTS 64
53 #define SAL_128_CONCURR_REQUESTS 128
54 #define SAL_256_CONCURR_REQUESTS 256
55 #define SAL_512_CONCURR_REQUESTS 512
56 #define SAL_1024_CONCURR_REQUESTS 1024
57 #define SAL_2048_CONCURR_REQUESTS 2048
58 #define SAL_4096_CONCURR_REQUESTS 4096
59 #define SAL_MAX_CONCURR_REQUESTS 65536
60 /**< Valid options for the num of concurrent requests per ring pair read
61 from the config file. These values are used to size the rings */
62
63 #define SAL_BATCH_SUBMIT_FREE_SPACE 2
64 /**< For data plane batch submissions ADF leaves 2 spaces free on the ring */
65
66 /*
67 ******************************************************************************
68 * Some common settings for QA API queries
69 ******************************************************************************
70 */
71
72 #define SAL_INFO2_VENDOR_NAME "Intel(R)"
73 /**< @ingroup LacCommon
74 * Name of vendor of this driver */
75 #define SAL_INFO2_PART_NAME "%s with Intel(R) QuickAssist Technology"
76 /**< @ingroup LacCommon
77 */
78
79 /*
80 ********************************************************************************
81 * User process name defines and functions
82 ********************************************************************************
83 */
84
85 #define LAC_USER_PROCESS_NAME_MAX_LEN 32
86 /**< @ingroup LacCommon
87 * Max length of user process name */
88
89 #define LAC_KERNEL_PROCESS_NAME "KERNEL_QAT"
90 /**< @ingroup LacCommon
91 * Default name for kernel process */
92
93 /*
94 ********************************************************************************
95 * response mode indicator from Config file
96 ********************************************************************************
97 */
98
99 #define SAL_RESP_POLL_CFG_FILE 1
100 #define SAL_RESP_EPOLL_CFG_FILE 2
101
102 /*
103 * @ingroup LacCommon
104 * @description
105 * This function sets the process name
106 *
107 * @context
108 * This functions is called from module_init or from user space process
109 * initialization function
110 *
111 * @assumptions
112 * None
113 * @sideEffects
114 * None
115 * @reentrant
116 * No
117 * @threadSafe
118 * No
119 *
120 * param[in] processName Process name to be set
121 */
122 CpaStatus icpSetProcessName(const char *processName);
123
124 /*
125 * @ingroup LacCommon
126 * @description
127 * This function gets the process name
128 *
129 * @context
130 * This functions is called from LAC context
131 *
132 * @assumptions
133 * None
134 * @sideEffects
135 * None
136 * @reentrant
137 * Yes
138 * @threadSafe
139 * Yes
140 *
141 */
142 char *icpGetProcessName(void);
143
144 /* Sections of the config file */
145 #define LAC_CFG_SECTION_GENERAL "GENERAL"
146 #define LAC_CFG_SECTION_INTERNAL "INTERNAL"
147
148 /*
149 ********************************************************************************
150 * Debug Macros and settings
151 ********************************************************************************
152 */
153
154 #define SEPARATOR "+--------------------------------------------------+\n"
155 /**< @ingroup LacCommon
156 * separator used for printing stats to standard output*/
157
158 #define BORDER "|"
159 /**< @ingroup LacCommon
160 * separator used for printing stats to standard output*/
161
162 /**
163 *****************************************************************************
164 * @ingroup LacCommon
165 * Component state
166 *
167 * @description
168 * This enum is used to indicate the state that the component is in. Its
169 * purpose is to prevent components from being initialised or shutdown
170 * incorrectly.
171 *
172 *****************************************************************************/
173 typedef enum {
174 LAC_COMP_SHUT_DOWN = 0,
175 /**< Component in the Shut Down state */
176 LAC_COMP_SHUTTING_DOWN,
177 /**< Component in the Process of Shutting down */
178 LAC_COMP_INITIALISING,
179 /**< Component in the Process of being initialised */
180 LAC_COMP_INITIALISED,
181 /**< Component in the initialised state */
182 } lac_comp_state_t;
183
184 /**
185 *******************************************************************************
186 * @ingroup LacCommon
187 * This macro checks if a parameter is NULL
188 *
189 * @param[in] param Parameter
190 *
191 * @return CPA_STATUS_INVALID_PARAM Parameter is NULL
192 * @return void Parameter is not NULL
193 ******************************************************************************/
194 #define LAC_CHECK_NULL_PARAM(param) \
195 do { \
196 if (NULL == (param)) { \
197 return CPA_STATUS_INVALID_PARAM; \
198 } \
199 } while (0)
200
201 /**
202 *******************************************************************************
203 * @ingroup LacCommon
204 * This macro checks if a parameter is within a specified range
205 *
206 * @param[in] param Parameter
207 * @param[in] min Parameter must be greater than OR equal to
208 *min
209 * @param[in] max Parameter must be less than max
210 *
211 * @return CPA_STATUS_INVALID_PARAM Parameter is outside range
212 * @return void Parameter is within range
213 ******************************************************************************/
214 #define LAC_CHECK_PARAM_RANGE(param, min, max) \
215 do { \
216 if (((param) < (min)) || ((param) >= (max))) { \
217 return CPA_STATUS_INVALID_PARAM; \
218 } \
219 } while (0)
220
221 /**
222 *******************************************************************************
223 * @ingroup LacCommon
224 * This checks if a param is 8 byte aligned.
225 *
226 ******************************************************************************/
227 #define LAC_CHECK_8_BYTE_ALIGNMENT(param) \
228 do { \
229 if ((Cpa64U)param % 8 != 0) { \
230 return CPA_STATUS_INVALID_PARAM; \
231 } \
232 } while (0)
233
234 /**
235 *******************************************************************************
236 * @ingroup LacCommon
237 * This checks if a param is 64 byte aligned.
238 *
239 ******************************************************************************/
240 #define LAC_CHECK_64_BYTE_ALIGNMENT(param) \
241 do { \
242 if ((LAC_ARCH_UINT)param % 64 != 0) { \
243 return CPA_STATUS_INVALID_PARAM; \
244 } \
245 } while (0)
246
247 /**
248 *******************************************************************************
249 * @ingroup LacCommon
250 * This macro returns the size of the buffer list structure given the
251 * number of elements in the buffer list - note: only the sizeof the
252 * buffer list structure is returned.
253 *
254 * @param[in] numBuffers The number of flatbuffers in a buffer list
255 *
256 * @return size of the buffer list structure
257 ******************************************************************************/
258 #define LAC_BUFFER_LIST_SIZE_GET(numBuffers) \
259 (sizeof(CpaBufferList) + (numBuffers * sizeof(CpaFlatBuffer)))
260
261 /**
262 *******************************************************************************
263 * @ingroup LacCommon
264 * This macro checks that a flatbuffer is valid i.e. that it is not
265 * null and the data it points to is not null
266 *
267 * @param[in] pFlatBuffer Pointer to flatbuffer
268 *
269 * @return CPA_STATUS_INVALID_PARAM Invalid flatbuffer pointer
270 * @return void flatbuffer is ok
271 ******************************************************************************/
272 #define LAC_CHECK_FLAT_BUFFER(pFlatBuffer) \
273 do { \
274 LAC_CHECK_NULL_PARAM((pFlatBuffer)); \
275 LAC_CHECK_NULL_PARAM((pFlatBuffer)->pData); \
276 } while (0)
277
278 /**
279 *******************************************************************************
280 * @ingroup LacCommon
281 * This macro verifies that the status is ok i.e. equal to CPA_STATUS_SUCCESS
282 *
283 * @param[in] status status we are checking
284 *
285 * @return void status is ok (CPA_STATUS_SUCCESS)
286 * @return status The value in the status parameter is an error one
287 *
288 ******************************************************************************/
289 #define LAC_CHECK_STATUS(status) \
290 do { \
291 if (CPA_STATUS_SUCCESS != (status)) { \
292 return status; \
293 } \
294 } while (0)
295
296 /**
297 *******************************************************************************
298 * @ingroup LacCommon
299 * This macro verifies that the Instance Handle is valid.
300 *
301 * @param[in] instanceHandle Instance Handle
302 *
303 * @return CPA_STATUS_INVALID_PARAM Parameter is NULL
304 * @return void Parameter is not NULL
305 *
306 ******************************************************************************/
307 #define LAC_CHECK_INSTANCE_HANDLE(instanceHandle) \
308 do { \
309 if (NULL == (instanceHandle)) { \
310 return CPA_STATUS_INVALID_PARAM; \
311 } \
312 } while (0)
313
314 /**
315 *******************************************************************************
316 * @ingroup LacCommon
317 * This macro copies a string from one location to another
318 *
319 * @param[out] pDestinationBuffer Pointer to destination buffer
320 * @param[in] pSource Pointer to source buffer
321 *
322 ******************************************************************************/
323 #define LAC_COPY_STRING(pDestinationBuffer, pSource) \
324 do { \
325 memcpy(pDestinationBuffer, pSource, (sizeof(pSource) - 1)); \
326 pDestinationBuffer[(sizeof(pSource) - 1)] = '\0'; \
327 } while (0)
328
329 /**
330 *******************************************************************************
331 * @ingroup LacCommon
332 * This macro fills a memory zone with ZEROES
333 *
334 * @param[in] pBuffer Pointer to buffer
335 * @param[in] count Buffer length
336 *
337 * @return void
338 *
339 ******************************************************************************/
340 #define LAC_OS_BZERO(pBuffer, count) memset(pBuffer, 0, count);
341
342 /**
343 *******************************************************************************
344 * @ingroup LacCommon
345 * This macro calculates the position of the given member in a struct
346 * Only for use on a struct where all members are of equal size to map
347 * the struct member position to an array index
348 *
349 * @param[in] structType the struct
350 * @param[in] member the member of the given struct
351 *
352 ******************************************************************************/
353 #define LAC_IDX_OF(structType, member) \
354 (offsetof(structType, member) / sizeof(((structType *)0)->member))
355
356 /*
357 ********************************************************************************
358 * Alignment, Bid define and Bit Operation Macros
359 ********************************************************************************
360 */
361
362 #define LAC_BIT31_SET 0x80000000 /**< bit 31 == 1 */
363 #define LAC_BIT7_SET 0x80 /**< bit 7 == 1 */
364 #define LAC_BIT6_SET 0x40 /**< bit 6 == 1 */
365 #define LAC_BIT5_SET 0x20 /**< bit 5 == 1 */
366 #define LAC_BIT4_SET 0x10 /**< bit 4 == 1 */
367 #define LAC_BIT3_SET 0x08 /**< bit 3 == 1 */
368 #define LAC_BIT2_SET 0x04 /**< bit 2 == 1 */
369 #define LAC_BIT1_SET 0x02 /**< bit 1 == 1 */
370 #define LAC_BIT0_SET 0x01 /**< bit 0 == 1 */
371
372 #define LAC_NUM_BITS_IN_BYTE (8)
373 /**< @ingroup LacCommon
374 * Number of bits in a byte */
375
376 #define LAC_LONG_WORD_IN_BYTES (4)
377 /**< @ingroup LacCommon
378 * Number of bytes in an IA word */
379
380 #define LAC_QUAD_WORD_IN_BYTES (8)
381 /**< @ingroup LacCommon
382 * Number of bytes in a QUAD word */
383
384 #define LAC_QAT_MAX_MSG_SZ_LW (32)
385 /**< @ingroup LacCommon
386 * Maximum size in Long Words for a QAT message */
387
388 /**
389 *****************************************************************************
390 * @ingroup LacCommon
391 * Alignment shift requirements of a buffer.
392 *
393 * @description
394 * This enum is used to indicate the alignment shift of a buffer.
395 * All alignments are to power of 2
396 *
397 *****************************************************************************/
398 typedef enum lac_aligment_shift_s {
399 LAC_NO_ALIGNMENT_SHIFT = 0,
400 /**< No alignment shift (to a power of 2)*/
401 LAC_8BYTE_ALIGNMENT_SHIFT = 3,
402 /**< 8 byte alignment shift (to a power of 2)*/
403 LAC_16BYTE_ALIGNMENT_SHIFT = 4,
404 /**< 16 byte alignment shift (to a power of 2)*/
405 LAC_64BYTE_ALIGNMENT_SHIFT = 6,
406 /**< 64 byte alignment shift (to a power of 2)*/
407 LAC_4KBYTE_ALIGNMENT_SHIFT = 12,
408 /**< 4k byte alignment shift (to a power of 2)*/
409 } lac_aligment_shift_t;
410
411 /**
412 *****************************************************************************
413 * @ingroup LacCommon
414 * Alignment of a buffer.
415 *
416 * @description
417 * This enum is used to indicate the alignment requirements of a buffer.
418 *
419 *****************************************************************************/
420 typedef enum lac_aligment_s {
421 LAC_NO_ALIGNMENT = 0,
422 /**< No alignment */
423 LAC_1BYTE_ALIGNMENT = 1,
424 /**< 1 byte alignment */
425 LAC_8BYTE_ALIGNMENT = 8,
426 /**< 8 byte alignment*/
427 LAC_64BYTE_ALIGNMENT = 64,
428 /**< 64 byte alignment*/
429 LAC_4KBYTE_ALIGNMENT = 4096,
430 /**< 4k byte alignment */
431 } lac_aligment_t;
432
433 /**
434 *****************************************************************************
435 * @ingroup LacCommon
436 * Size of a buffer.
437 *
438 * @description
439 * This enum is used to indicate the required size.
440 * The buffer must be a multiple of the required size.
441 *
442 *****************************************************************************/
443 typedef enum lac_expected_size_s {
444 LAC_NO_LENGTH_REQUIREMENTS = 0,
445 /**< No requirement for size */
446 LAC_4KBYTE_MULTIPLE_REQUIRED = 4096,
447 /**< 4k multiple requirement for size */
448 } lac_expected_size_t;
449
450 #define LAC_OPTIMAL_ALIGNMENT_SHIFT LAC_64BYTE_ALIGNMENT_SHIFT
451 /**< @ingroup LacCommon
452 * optimal alignment to a power of 2 */
453
454 #define LAC_SHIFT_8 (1 << LAC_8BYTE_ALIGNMENT_SHIFT)
455 /**< shift by 8 bits */
456 #define LAC_SHIFT_24 \
457 ((1 << LAC_8BYTE_ALIGNMENT_SHIFT) + (1 << LAC_16BYTE_ALIGNMENT_SHIFT))
458 /**< shift by 24 bits */
459
460 #define LAC_MAX_16_BIT_VALUE ((1 << 16) - 1)
461 /**< @ingroup LacCommon
462 * maximum value a 16 bit type can hold */
463
464 /**
465 *******************************************************************************
466 * @ingroup LacCommon
467 * This macro can be used to avoid an unused variable warning from the
468 * compiler
469 *
470 * @param[in] variable unused variable
471 *
472 ******************************************************************************/
473 #define LAC_UNUSED_VARIABLE(x) (void)(x)
474
475 /**
476 *******************************************************************************
477 * @ingroup LacCommon
478 * This macro checks if an address is aligned to the specified power of 2
479 * Returns 0 if alignment is ok, or non-zero otherwise
480 *
481 * @param[in] address the address we are checking
482 *
483 * @param[in] alignment the byte alignment to check (specified as power of 2)
484 *
485 ******************************************************************************/
486 #define LAC_ADDRESS_ALIGNED(address, alignment) \
487 (!((LAC_ARCH_UINT)(address) & ((1 << (alignment)) - 1)))
488
489 /**
490 *******************************************************************************
491 * @ingroup LacCommon
492 * This macro rounds up a number to a be a multiple of the alignment when
493 * the alignment is a power of 2.
494 *
495 * @param[in] num Number
496 * @param[in] align Alignment (must be a power of 2)
497 *
498 ******************************************************************************/
499 #define LAC_ALIGN_POW2_ROUNDUP(num, align) (((num) + (align)-1) & ~((align)-1))
500
501 /**
502 *******************************************************************************
503 * @ingroup LacCommon
504 * This macro generates a bit mask to select a particular bit
505 *
506 * @param[in] bitPos Bit position to select
507 *
508 ******************************************************************************/
509 #define LAC_BIT(bitPos) (0x1 << (bitPos))
510
511 /**
512 *******************************************************************************
513 * @ingroup LacCommon
514 * This macro converts a size in bits to the equivalent size in bytes,
515 * using a bit shift to divide by 8
516 *
517 * @param[in] x size in bits
518 *
519 ******************************************************************************/
520 #define LAC_BITS_TO_BYTES(x) ((x) >> 3)
521
522 /**
523 *******************************************************************************
524 * @ingroup LacCommon
525 * This macro converts a size in bytes to the equivalent size in bits,
526 * using a bit shift to multiply by 8
527 *
528 * @param[in] x size in bytes
529 *
530 ******************************************************************************/
531 #define LAC_BYTES_TO_BITS(x) ((x) << 3)
532
533 /**
534 *******************************************************************************
535 * @ingroup LacCommon
536 * This macro converts a size in bytes to the equivalent size in longwords,
537 * using a bit shift to divide by 4
538 *
539 * @param[in] x size in bytes
540 *
541 ******************************************************************************/
542 #define LAC_BYTES_TO_LONGWORDS(x) ((x) >> 2)
543
544 /**
545 *******************************************************************************
546 * @ingroup LacCommon
547 * This macro converts a size in longwords to the equivalent size in bytes,
548 * using a bit shift to multiply by 4
549 *
550 * @param[in] x size in long words
551 *
552 ******************************************************************************/
553 #define LAC_LONGWORDS_TO_BYTES(x) ((x) << 2)
554
555 /**
556 *******************************************************************************
557 * @ingroup LacCommon
558 * This macro converts a size in bytes to the equivalent size in quadwords,
559 * using a bit shift to divide by 8
560 *
561 * @param[in] x size in bytes
562 *
563 ******************************************************************************/
564 #define LAC_BYTES_TO_QUADWORDS(x) (((x) >> 3) + (((x) % 8) ? 1 : 0))
565
566 /**
567 *******************************************************************************
568 * @ingroup LacCommon
569 * This macro converts a size in quadwords to the equivalent size in bytes,
570 * using a bit shift to multiply by 8
571 *
572 * @param[in] x size in quad words
573 *
574 ******************************************************************************/
575 #define LAC_QUADWORDS_TO_BYTES(x) ((x) << 3)
576
577
578 /******************************************************************************/
579
580 /*
581 *******************************************************************************
582 * Mutex Macros
583 *******************************************************************************
584 */
585
586 /**
587 *******************************************************************************
588 * @ingroup LacCommon
589 * This macro tries to acquire a mutex and returns the status
590 *
591 * @param[in] pLock Pointer to Lock
592 * @param[in] timeout Timeout
593 *
594 * @retval CPA_STATUS_SUCCESS Function executed successfully.
595 * @retval CPA_STATUS_RESOURCE Error with Mutex
596 ******************************************************************************/
597 #define LAC_LOCK_MUTEX(pLock, timeout) \
598 ((CPA_STATUS_SUCCESS != qatUtilsMutexLock((pLock), (timeout))) ? \
599 CPA_STATUS_RESOURCE : \
600 CPA_STATUS_SUCCESS)
601
602 /**
603 *******************************************************************************
604 * @ingroup LacCommon
605 * This macro unlocks a mutex and returns the status
606 *
607 * @param[in] pLock Pointer to Lock
608 *
609 * @retval CPA_STATUS_SUCCESS Function executed successfully.
610 * @retval CPA_STATUS_RESOURCE Error with Mutex
611 ******************************************************************************/
612 #define LAC_UNLOCK_MUTEX(pLock) \
613 ((CPA_STATUS_SUCCESS != qatUtilsMutexUnlock((pLock))) ? \
614 CPA_STATUS_RESOURCE : \
615 CPA_STATUS_SUCCESS)
616
617 /**
618 *******************************************************************************
619 * @ingroup LacCommon
620 * This macro initialises a mutex and returns the status
621 *
622 * @param[in] pLock Pointer to Lock
623 *
624 * @retval CPA_STATUS_SUCCESS Function executed successfully.
625 * @retval CPA_STATUS_RESOURCE Error with Mutex
626 ******************************************************************************/
627 #define LAC_INIT_MUTEX(pLock) \
628 ((CPA_STATUS_SUCCESS != qatUtilsMutexInit((pLock))) ? \
629 CPA_STATUS_RESOURCE : \
630 CPA_STATUS_SUCCESS)
631
632 /**
633 *******************************************************************************
634 * @ingroup LacCommon
635 * This macro destroys a mutex and returns the status
636 *
637 * @param[in] pLock Pointer to Lock
638 *
639 * @retval CPA_STATUS_SUCCESS Function executed successfully.
640 * @retval CPA_STATUS_RESOURCE Error with Mutex
641 ******************************************************************************/
642 #define LAC_DESTROY_MUTEX(pLock) \
643 ((CPA_STATUS_SUCCESS != qatUtilsMutexDestroy((pLock))) ? \
644 CPA_STATUS_RESOURCE : \
645 CPA_STATUS_SUCCESS)
646
647 /**
648 *******************************************************************************
649 * @ingroup LacCommon
650 * This macro calls a trylock on a mutex
651 *
652 * @param[in] pLock Pointer to Lock
653 *
654 * @retval CPA_STATUS_SUCCESS Function executed successfully.
655 * @retval CPA_STATUS_RESOURCE Error with Mutex
656 ******************************************************************************/
657 #define LAC_TRYLOCK_MUTEX(pLock) \
658 ((CPA_STATUS_SUCCESS != \
659 qatUtilsMutexTryLock((pLock), QAT_UTILS_WAIT_NONE)) ? \
660 CPA_STATUS_RESOURCE : \
661 CPA_STATUS_SUCCESS)
662
663 /*
664 *******************************************************************************
665 * Semaphore Macros
666 *******************************************************************************
667 */
668
669 /**
670 *******************************************************************************
671 * @ingroup LacCommon
672 * This macro waits on a semaphore and returns the status
673 *
674 * @param[in] sid The semaphore
675 * @param[in] timeout Timeout
676 *
677 * @retval CPA_STATUS_SUCCESS Function executed successfully.
678 * @retval CPA_STATUS_RESOURCE Error with semaphore
679 ******************************************************************************/
680 #define LAC_WAIT_SEMAPHORE(sid, timeout) \
681 ((CPA_STATUS_SUCCESS != qatUtilsSemaphoreWait(&sid, (timeout))) ? \
682 CPA_STATUS_RESOURCE : \
683 CPA_STATUS_SUCCESS)
684
685 /**
686 *******************************************************************************
687 * @ingroup LacCommon
688 * This macro checks a semaphore and returns the status
689 *
690 * @param[in] sid The semaphore
691 *
692 * @retval CPA_STATUS_SUCCESS Function executed successfully.
693 * @retval CPA_STATUS_RESOURCE Error with semaphore
694 ******************************************************************************/
695 #define LAC_CHECK_SEMAPHORE(sid) \
696 ((CPA_STATUS_SUCCESS != qatUtilsSemaphoreTryWait(&sid)) ? \
697 CPA_STATUS_RETRY : \
698 CPA_STATUS_SUCCESS)
699
700 /**
701 *******************************************************************************
702 * @ingroup LacCommon
703 * This macro post a semaphore and returns the status
704 *
705 * @param[in] sid The semaphore
706 *
707 * @retval CPA_STATUS_SUCCESS Function executed successfully.
708 * @retval CPA_STATUS_RESOURCE Error with semaphore
709 ******************************************************************************/
710 #define LAC_POST_SEMAPHORE(sid) \
711 ((CPA_STATUS_SUCCESS != qatUtilsSemaphorePost(&sid)) ? \
712 CPA_STATUS_RESOURCE : \
713 CPA_STATUS_SUCCESS)
714 /**
715 *******************************************************************************
716 * @ingroup LacCommon
717 * This macro initialises a semaphore and returns the status
718 *
719 * @param[in] sid The semaphore
720 * @param[in] semValue Initial semaphore value
721 *
722 * @retval CPA_STATUS_SUCCESS Function executed successfully.
723 * @retval CPA_STATUS_RESOURCE Error with semaphore
724 ******************************************************************************/
725 #define LAC_INIT_SEMAPHORE(sid, semValue) \
726 ((CPA_STATUS_SUCCESS != qatUtilsSemaphoreInit(&sid, semValue)) ? \
727 CPA_STATUS_RESOURCE : \
728 CPA_STATUS_SUCCESS)
729
730 /**
731 *******************************************************************************
732 * @ingroup LacCommon
733 * This macro destroys a semaphore and returns the status
734 *
735 * @param[in] sid The semaphore
736 *
737 * @retval CPA_STATUS_SUCCESS Function executed successfully.
738 * @retval CPA_STATUS_RESOURCE Error with semaphore
739 ******************************************************************************/
740 #define LAC_DESTROY_SEMAPHORE(sid) \
741 ((CPA_STATUS_SUCCESS != qatUtilsSemaphoreDestroy(&sid)) ? \
742 CPA_STATUS_RESOURCE : \
743 CPA_STATUS_SUCCESS)
744
745 /*
746 *******************************************************************************
747 * Spinlock Macros
748 *******************************************************************************
749 */
750 typedef struct mtx *lac_lock_t;
751 #define LAC_SPINLOCK_INIT(lock) \
752 ((CPA_STATUS_SUCCESS != qatUtilsLockInit(lock)) ? \
753 CPA_STATUS_RESOURCE : \
754 CPA_STATUS_SUCCESS)
755 #define LAC_SPINLOCK(lock) \
756 ({ \
757 (void)qatUtilsLock(lock); \
758 })
759 #define LAC_SPINUNLOCK(lock) \
760 ({ \
761 (void)qatUtilsUnlock(lock); \
762 })
763 #define LAC_SPINLOCK_DESTROY(lock) \
764 ({ \
765 (void)qatUtilsLockDestroy(lock); \
766 })
767
768 #define LAC_CONST_PTR_CAST(castee) ((void *)(LAC_ARCH_UINT)(castee))
769 #define LAC_CONST_VOLATILE_PTR_CAST(castee) ((void *)(LAC_ARCH_UINT)(castee))
770
771 /* Type of ring */
772 #define SAL_RING_TYPE_NONE 0
773 #define SAL_RING_TYPE_A_SYM_HI 1
774 #define SAL_RING_TYPE_A_SYM_LO 2
775 #define SAL_RING_TYPE_A_ASYM 3
776 #define SAL_RING_TYPE_B_SYM_HI 4
777 #define SAL_RING_TYPE_B_SYM_LO 5
778 #define SAL_RING_TYPE_B_ASYM 6
779 #define SAL_RING_TYPE_DC 7
780 #define SAL_RING_TYPE_ADMIN 8
781 #define SAL_RING_TYPE_TRNG 9
782
783 /* Maps Ring Service to generic service type */
784 static inline icp_adf_ringInfoService_t
lac_getRingType(int type)785 lac_getRingType(int type)
786 {
787 switch (type) {
788 case SAL_RING_TYPE_NONE:
789 return ICP_ADF_RING_SERVICE_0;
790 case SAL_RING_TYPE_A_SYM_HI:
791 return ICP_ADF_RING_SERVICE_1;
792 case SAL_RING_TYPE_A_SYM_LO:
793 return ICP_ADF_RING_SERVICE_2;
794 case SAL_RING_TYPE_A_ASYM:
795 return ICP_ADF_RING_SERVICE_3;
796 case SAL_RING_TYPE_B_SYM_HI:
797 return ICP_ADF_RING_SERVICE_4;
798 case SAL_RING_TYPE_B_SYM_LO:
799 return ICP_ADF_RING_SERVICE_5;
800 case SAL_RING_TYPE_B_ASYM:
801 return ICP_ADF_RING_SERVICE_6;
802 case SAL_RING_TYPE_DC:
803 return ICP_ADF_RING_SERVICE_7;
804 case SAL_RING_TYPE_ADMIN:
805 return ICP_ADF_RING_SERVICE_8;
806 case SAL_RING_TYPE_TRNG:
807 return ICP_ADF_RING_SERVICE_9;
808 default:
809 return ICP_ADF_RING_SERVICE_0;
810 }
811 return ICP_ADF_RING_SERVICE_0;
812 }
813
814 /* Maps generic service type to Ring Service type */
815 static inline int
lac_getServiceType(icp_adf_ringInfoService_t type)816 lac_getServiceType(icp_adf_ringInfoService_t type)
817 {
818 switch (type) {
819 case ICP_ADF_RING_SERVICE_0:
820 return SAL_RING_TYPE_NONE;
821 case ICP_ADF_RING_SERVICE_1:
822 return SAL_RING_TYPE_A_SYM_HI;
823 case ICP_ADF_RING_SERVICE_2:
824 return SAL_RING_TYPE_A_SYM_LO;
825 case ICP_ADF_RING_SERVICE_3:
826 return SAL_RING_TYPE_A_ASYM;
827 case ICP_ADF_RING_SERVICE_4:
828 return SAL_RING_TYPE_B_SYM_HI;
829 case ICP_ADF_RING_SERVICE_5:
830 return SAL_RING_TYPE_B_SYM_LO;
831 case ICP_ADF_RING_SERVICE_6:
832 return SAL_RING_TYPE_B_ASYM;
833 case ICP_ADF_RING_SERVICE_7:
834 return SAL_RING_TYPE_DC;
835 case ICP_ADF_RING_SERVICE_8:
836 return SAL_RING_TYPE_ADMIN;
837 default:
838 return SAL_RING_TYPE_NONE;
839 }
840 return SAL_RING_TYPE_NONE;
841 }
842
843 #endif /* LAC_COMMON_H */
844