FreeBSD/Linux Kernel Cross Reference
sys/dev/qat/qat_api/include/dc/cpa_dc_dp.h

     /***************************************************************************
      *
      *   BSD LICENSE
      * 
      *   Copyright(c) 2007-2022 Intel Corporation. All rights reserved.
      *   All rights reserved.
      * 
      *   Redistribution and use in source and binary forms, with or without
      *   modification, are permitted provided that the following conditions
     *   are met:
     * 
     *     * Redistributions of source code must retain the above copyright
     *       notice, this list of conditions and the following disclaimer.
     *     * Redistributions in binary form must reproduce the above copyright
     *       notice, this list of conditions and the following disclaimer in
     *       the documentation and/or other materials provided with the
     *       distribution.
     *     * Neither the name of Intel Corporation nor the names of its
     *       contributors may be used to endorse or promote products derived
     *       from this software without specific prior written permission.
     * 
     *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     * 
     *
     ***************************************************************************/
    
    /*
     *****************************************************************************
     * Doxygen group definitions
     ****************************************************************************/
    
    /**
     *****************************************************************************
     * @file cpa_dc_dp.h
     *
     * @defgroup cpaDcDp Data Compression Data Plane API
     *
     * @ingroup cpaDc
     *
     * @description
     *      These data structures and functions specify the Data Plane API
     *      for compression and decompression operations.
     *
     *      This API is recommended for data plane applications, in which the
     *      cost of offload - that is, the cycles consumed by the driver in
     *      sending requests to the hardware, and processing responses - needs
     *      to be minimized.  In particular, use of this API is recommended
     *      if the following constraints are acceptable to your application:
     *
     *      - Thread safety is not guaranteed.  Each software thread should
     *        have access to its own unique instance (CpaInstanceHandle) to
     *        avoid contention.
     *      - Polling is used, rather than interrupts (which are expensive).
     *        Implementations of this API will provide a function (not
     *        defined as part of this API) to read responses from the hardware
     *        response queue and dispatch callback functions, as specified on
     *        this API.
     *      - Buffers and buffer lists are passed using physical addresses,
     *        to avoid virtual to physical address translation costs.
     *      - The ability to enqueue one or more requests without submitting
     *        them to the hardware allows for certain costs to be amortized
     *        across multiple requests.
     *      - Only asynchronous invocation is supported.
     *      - There is no support for partial packets.
     *      - Implementations may provide certain features as optional at
     *        build time, such as atomic counters.
     *      - There is no support for stateful operations.
     *        - The "default" instance (CPA_INSTANCE_HANDLE_SINGLE) is not
     *          supported on this API.  The specific handle should be obtained
     *          using the instance discovery functions (@ref cpaDcGetNumInstances,
     *          @ref cpaDcGetInstances).
     *
     *****************************************************************************/
    
    #ifndef CPA_DC_DP_H
    #define CPA_DC_DP_H
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    #include "cpa_dc.h"
    
    /**
     *****************************************************************************
     * @ingroup cpaDcDp
     *      Operation Data for compression data plane API.
     *
     * @description
    *      This structure contains data relating to a request to perform
    *      compression processing on one or more data buffers.
    *
    *      The physical memory to which this structure points should be
    *      at least 8-byte aligned.
    *
    *      All reserved fields SHOULD NOT be written or read by the
    *      calling code.
    *
    * @see
    *        cpaDcDpEnqueueOp, cpaDcDpEnqueueOpBatch
    ****************************************************************************/
   typedef struct _CpaDcDpOpData
   {
       Cpa64U          reserved0;
       /**< Reserved for internal use.  Source code should not read or write
         * this field.
         */
       Cpa32U          bufferLenToCompress;
       /**< The number of bytes from the source buffer to compress.  This must be
        * less than, or more typically equal to, the total size of the source
        * buffer (or buffer list).
        */
   
       Cpa32U          bufferLenForData;
       /**< The maximum number of bytes that should be written to the destination
        * buffer.  This must be less than, or more typically equal to, the total
        * size of the destination buffer (or buffer list).
        */
   
       Cpa64U          reserved1;
       /**< Reserved for internal use.  Source code should not read or write */
   
       Cpa64U          reserved2;
       /**< Reserved for internal use.  Source code should not read or write */
   
       Cpa64U          reserved3;
       /**< Reserved for internal use.  Source code should not read or write */
   
       CpaDcRqResults      results;
       /**< Results of the operation.  Contents are valid upon completion. */
   
       CpaInstanceHandle   dcInstance;
       /**< Instance to which the request is to be enqueued */
   
       CpaDcSessionHandle  pSessionHandle;
       /**< DC Session associated with the stream of requests */
   
       CpaPhysicalAddr     srcBuffer;
       /**< Physical address of the source buffer on which to operate.
        * This is either the location of the data, of length srcBufferLen; or,
        * if srcBufferLen has the special value @ref CPA_DP_BUFLIST, then
        * srcBuffer contains the location where a @ref CpaPhysBufferList is
        * stored.
        */
   
       Cpa32U          srcBufferLen;
       /**< If the source buffer is a "flat buffer", then this field
        * specifies the size of the buffer, in bytes. If the source buffer
        * is a "buffer list" (of type @ref CpaPhysBufferList), then this field
        * should be set to the value @ref CPA_DP_BUFLIST.
        */
   
       CpaPhysicalAddr     destBuffer;
       /**< Physical address of the destination buffer on which to operate.
        * This is either the location of the data, of length destBufferLen; or,
        * if destBufferLen has the special value @ref CPA_DP_BUFLIST, then
        * destBuffer contains the location where a @ref CpaPhysBufferList is
        * stored.
        */
   
       Cpa32U          destBufferLen;
       /**< If the destination buffer is a "flat buffer", then this field
        * specifies the size of the buffer, in bytes.  If the destination buffer
        * is a "buffer list" (of type @ref CpaPhysBufferList), then this field
        * should be set to the value @ref CPA_DP_BUFLIST.
        */
   
       CpaDcSessionDir sessDirection;
        /**<Session direction indicating whether session is used for
         * compression, decompression.  For the DP implementation,
         * CPA_DC_DIR_COMBINED is not a valid selection.
         */
   
       CpaBoolean compressAndVerify;
       /**< If set to true, for compression operations, the implementation
        * will verify that compressed data, generated by the compression
        * operation, can be successfully decompressed.
        * This behavior is only supported for stateless compression.
        * This behavior is only supported on instances that support the
        * compressAndVerify capability. */
   
       CpaBoolean compressAndVerifyAndRecover;
       /**< If set to true, for compression operations, the implementation
        * will automatically recover from a compressAndVerify error.
        * This behavior is only supported for stateless compression.
        * This behavior is only supported on instances that support the
        * compressAndVerifyAndRecover capability.
        * The compressAndVerify field in CpaDcOpData MUST be set to CPA_TRUE
        * if compressAndVerifyAndRecover is set to CPA_TRUE. */
   
       CpaStatus responseStatus;
       /**< Status of the operation. Valid values are CPA_STATUS_SUCCESS,
        * CPA_STATUS_FAIL and CPA_STATUS_UNSUPPORTED.
        */
   
       CpaPhysicalAddr thisPhys;
       /**< Physical address of this data structure */
   
       void* pCallbackTag;
       /**< Opaque data that will be returned to the client in the function
        * completion callback.
        *
        * This opaque data is not used by the implementation of the API,
        * but is simply returned as part of the asynchronous response.
        * It may be used to store information that might be useful when
        * processing the response later.
        */
   } CpaDcDpOpData;
   
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Definition of callback function for compression data plane API.
    *
    * @description
    *      This is the callback function prototype. The callback function is
    *      registered by the application using the @ref cpaDcDpRegCbFunc
    *      function call, and called back on completion of asycnhronous
    *      requests made via calls to @ref cpaDcDpEnqueueOp or @ref
    *      cpaDcDpEnqueueOpBatch.
    *
    * @context
    *      This callback function can be executed in a context that DOES NOT
    *      permit sleeping to occur.
    * @assumptions
    *      None
    * @sideEffects
    *      None
    * @reentrant
    *      No
    * @threadSafe
    *      No
    *
    * @param[in] pOpData           Pointer to the @ref CpaDcDpOpData object which
    *                              was supplied as part of the original request.
   
    * @return
    *      None
    * @pre
    *      Instance has been initialized.
    *      Callback has been registered with @ref cpaDcDpRegCbFunc.
    * @post
    *      None
    * @note
    *      None
    * @see
    *      @ref cpaDcDpRegCbFunc
    *****************************************************************************/
   typedef void (*CpaDcDpCallbackFn)(CpaDcDpOpData *pOpData);
   
   /**
    *****************************************************************************
    * @ingroup cpaDc
    *      Get the size of the memory required to hold the data plane
    *      session information.
    *
    * @description
    *
    *      The client of the Data Compression API is responsible for
    *      allocating sufficient memory to hold session information. This
    *      function provides a means for determining the size of the session
    *      information and statistics information.
    *
    * @context
    *      No restrictions
    * @assumptions
    *      None
    * @sideEffects
    *      None
    * @blocking
    *      Yes
    * @reentrant
    *      No
    * @threadSafe
    *      Yes
    *
    * @param[in] dcInstance            Instance handle.
    * @param[in] pSessionData          Pointer to a user instantiated structure
    *                                  containing session data.
    * @param[out] pSessionSize         On return, this parameter will be the size
    *                                  of the memory that will be
    *                                  required by cpaDcInitSession() for session
    *                                  data.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      None
    * @post
    *      None
    * @note
    *      Only a synchronous version of this function is provided.
    *
    *      Session data is expected to include interim checksum values, various
    *      counters and other other session related data that needs to persist
    *      between invocations.
    *      For a given implementation of this API, it is safe to assume that
    *      cpaDcDpGetSessionSize() will always return the same session size and
    *      that the size will not be different for different setup data
    *      parameters. However, it should be noted that the size may change:
    *       (1) between different implementations of the API (e.g. between software
    *           and hardware implementations or between different hardware
    *           implementations)
    *       (2) between different releases of the same API implementation
    *
    * @see
    *      cpaDcDpInitSession()
    *
    *****************************************************************************/
   CpaStatus
   cpaDcDpGetSessionSize(CpaInstanceHandle dcInstance,
           CpaDcSessionSetupData* pSessionData,
           Cpa32U* pSessionSize );
   
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Initialize compression or decompression data plane session.
    *
    * @description
    *      This function is used to initialize a compression/decompression session.
    *      A single session can be used for both compression and decompression
    *      requests.  Clients MUST register a callback
    *      function for the compression service using this function.
    *      This function returns a unique session handle each time this function
    *      is invoked.
    *      The order of the callbacks are guaranteed to be in the same order the
    *      compression or decompression requests were submitted for each session,
    *      so long as a single thread of execution is used for job submission.
    *
    * @context
    *      This function may be called from any context.
    * @assumptions
    *      None
    * @sideEffects
    *      None
    * @blocking
    *      Yes
    * @reentrant
    *      No
    * @threadSafe
    *      Yes
    *
    * @param[in]       dcInstance      Instance handle derived from discovery
    *                                  functions.
    * @param[in,out]   pSessionHandle  Pointer to a session handle.
    * @param[in,out]   pSessionData    Pointer to a user instantiated structure
    *                                  containing session data.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESOURCE       Error related to system resources.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      dcInstance has been started using @ref cpaDcStartInstance.
    * @post
    *      None
    * @note
    *      Only a synchronous version of this function is provided.
    *
    *      This initializes opaque data structures in the session handle. Data
    *      compressed under this session will be compressed to the level
    *      specified in the pSessionData structure. Lower compression level
    *      numbers indicate a request for faster compression at the
    *      expense of compression ratio.  Higher compression level numbers
    *      indicate a request for higher compression ratios at the expense of
    *      execution time.
    *
    *      The session is opaque to the user application and the session handle
    *      contains job specific data.
    *
    *      The window size specified in the pSessionData must match exactly
    *      one of the supported window sizes specified in the capability
    *      structure.  If a bi-directional session is being initialized, then
    *      the window size must be valid for both compress and decompress.
    *
    *      Note stateful sessions are not supported by this API.
    *
    * @see
    *      None
    *
    *****************************************************************************/
   CpaStatus
   cpaDcDpInitSession( CpaInstanceHandle       dcInstance,
           CpaDcSessionHandle              pSessionHandle,
           CpaDcSessionSetupData           *pSessionData );
   
   
   /**
    *****************************************************************************
    * @ingroup cpaDc
    *      Compression Data Plane Session Remove Function.
    *
    * @description
    *      This function will remove a previously initialized session handle
    *      and the installed callback handler function. Removal will fail if
    *      outstanding calls still exist for the initialized session handle.
    *      The client needs to retry the remove function at a later time.
    *      The memory for the session handle MUST not be freed until this call
    *      has completed successfully.
    *
    * @context
    *      This is a synchronous function that cannot sleep. It can be
    *      executed in a context that does not permit sleeping.
    * @assumptions
    *      None
    * @sideEffects
    *      None
    * @blocking
    *      No.
    * @reentrant
    *      No
    * @threadSafe
    *      Yes
    *
    * @param[in]      dcInstance      Instance handle.
    * @param[in,out]  pSessionHandle  Session handle.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_RETRY          Resubmit the request.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESOURCE       Error related to system resources.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      The component has been initialized via @ref cpaDcStartInstance function.
    * @post
    *      None
    * @note
    *      This is a synchronous function and has no completion callback
    *      associated with it.
    *
    * @see
    *      @ref cpaDcDpInitSession
    *
    *****************************************************************************/
   CpaStatus
   cpaDcDpRemoveSession(const CpaInstanceHandle dcInstance,
           CpaDcSessionHandle pSessionHandle );
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Registration of the operation completion callback function.
    *
    * @description
    *      This function allows a completion callback function to be registered.
    *      The registered callback function is invoked on completion of
    *      asycnhronous requests made via calls to @ref cpaDcDpEnqueueOp
    *      or @ref cpaDcDpEnqueueOpBatch.
    * @context
    *      This is a synchronous function and it cannot sleep. It can be
    *      executed in a context that DOES NOT permit sleeping.
    * @assumptions
    *      None
    * @sideEffects
    *      None
    * @reentrant
    *      No
    * @threadSafe
    *      No
    *
    * @param[in] dcInstance     Instance on which the callback function is to be
    *                           registered.
    * @param[in] pNewCb         Callback function for this instance.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESOURCE       Error related to system resources.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      Instance has been initialized.
    * @post
    *      None
    * @note
    *      None
    * @see
    *      cpaDcDpCbFunc
    *****************************************************************************/
   CpaStatus cpaDcDpRegCbFunc(const CpaInstanceHandle dcInstance,
           const CpaDcDpCallbackFn pNewCb);
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Enqueue a single compression or decompression request.
    *
    * @description
    *      This function enqueues a single request to perform a compression,
    *      decompression operation.
    *
    *      The function is asynchronous; control is returned to the user once
    *      the request has been submitted.  On completion of the request, the
    *      application may poll for responses, which will cause a callback
    *      function (registered via @ref cpaDcDpRegCbFunc) to be invoked.
    *      Callbacks within a session are guaranteed
    *      to be in the same order in which they were submitted.
    *
    *      The following restrictions apply to the pOpData parameter:
    *
    *      - The memory MUST be aligned on an 8-byte boundary.
    *      - The reserved fields of the structure MUST NOT be written to
    *        or read from.
    *      - The structure MUST reside in physically contiguous memory.
    *
    * @context
    *      This function will not sleep, and hence can be executed in a context
    *      that does not permit sleeping.
    *
    * @sideEffects
    *      None
    * @blocking
    *      No
    * @reentrant
    *      No
    * @threadSafe
    *      No
    *
    * @param[in] pOpData           Pointer to a structure containing the
    *                              request parameters. The client code allocates
    *                              the memory for this structure. This component
    *                              takes ownership of the memory until it is
    *                              returned in the callback, which was registered
    *                              on the instance via @ref cpaDcDpRegCbFunc.
    *                              See the above Description for some restrictions
    *                              that apply to this parameter.
    * @param[in] performOpNow      Flag to indicate whether the operation should be
    *                              performed immediately (CPA_TRUE), or simply
    *                              enqueued to be performed later (CPA_FALSE).
    *                              In the latter case, the request is submitted
    *                              to be performed either by calling this function
    *                              again with this flag set to CPA_TRUE, or by
    *                              invoking the function @ref
    *                              cpaDcDpPerformOpNow.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_RETRY          Resubmit the request.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      The session identified by pOpData->pSessionHandle was setup using
    *      @ref cpaDcDpInitSession.
    *      The instance identified by pOpData->dcInstance has had a
    *      callback function registered via @ref cpaDcDpRegCbFunc.
    *
    * @post
    *      None
    *
    * @note
    *      A callback of type @ref CpaDcDpCallbackFn is generated in
    *      response to this function call. Any errors generated during
    *      processing are reported as part of the callback status code.
    *
    * @see
    *      @ref cpaDcDpPerformOpNow
    *****************************************************************************/
   
   
   CpaStatus
   cpaDcDpEnqueueOp(CpaDcDpOpData *pOpData,
           const CpaBoolean performOpNow);
   
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Enqueue multiple requests to the compression data plane API.
    *
    * @description
    *      This function enqueues multiple requests to perform compression or
    *      decompression operations.
    *
    *      The function is asynchronous; control is returned to the user once
    *      the request has been submitted.  On completion of the request, the
    *      application may poll for responses, which will cause a callback
    *      function (registered via @ref cpaDcDpRegCbFunc) to be invoked.
    *      Separate callbacks will be invoked for each request.
    *      Callbacks within a session and at the same priority are guaranteed
    *      to be in the same order in which they were submitted.
    *
    *      The following restrictions apply to each element of the pOpData
    *      array:
    *
    *      - The memory MUST be aligned on an 8-byte boundary.
    *      - The reserved fields of the structure MUST be set to zero.
    *      - The structure MUST reside in physically contiguous memory.
    *
    * @context
    *      This function will not sleep, and hence can be executed in a context
    *      that does not permit sleeping.
    *
    * @assumptions
    *      Client MUST allocate the request parameters to 8 byte alignment.
    *      Reserved elements of the CpaDcDpOpData structure MUST not used
    *      The CpaDcDpOpData structure MUST reside in physically
    *      contiguous memory.
    *
    * @sideEffects
    *      None
    * @blocking
    *      No
    * @reentrant
    *      No
    * @threadSafe
    *      No
    *
    * @param[in] numberRequests    The number of requests in the array of
    *                              CpaDcDpOpData structures.
    * @param[in] pOpData           An array of pointers to CpaDcDpOpData
    *                              structures.  Each CpaDcDpOpData
    *                              structure contains the request parameters for
    *                              that request. The client code allocates the
    *                              memory for this structure. This component takes
    *                              ownership of the memory until it is returned in
    *                              the callback, which was registered on the
    *                              instance via @ref cpaDcDpRegCbFunc.
    *                              See the above Description for some restrictions
    *                              that apply to this parameter.
    * @param[in] performOpNow      Flag to indicate whether the operation should be
    *                              performed immediately (CPA_TRUE), or simply
    *                              enqueued to be performed later (CPA_FALSE).
    *                              In the latter case, the request is submitted
    *                              to be performed either by calling this function
    *                              again with this flag set to CPA_TRUE, or by
    *                              invoking the function @ref
    *                              cpaDcDpPerformOpNow.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_RETRY          Resubmit the request.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      The session identified by pOpData[i]->pSessionHandle was setup using
    *      @ref cpaDcDpInitSession.
    *      The instance identified by pOpData[i]->dcInstance has had a
    *      callback function registered via @ref cpaDcDpRegCbFunc.
    *
    * @post
    *      None
    *
    * @note
    *      Multiple callbacks of type @ref CpaDcDpCallbackFn are generated in
    *      response to this function call (one per request).  Any errors
    *      generated during processing are reported as part of the callback
    *      status code.
    *
    * @see
    *      cpaDcDpEnqueueOp
    *****************************************************************************/
   CpaStatus
   cpaDcDpEnqueueOpBatch(const Cpa32U numberRequests,
           CpaDcDpOpData *pOpData[],
           const CpaBoolean performOpNow);
   
   
   /**
    *****************************************************************************
    * @ingroup cpaDcDp
    *      Submit any previously enqueued requests to be performed now on the
    *      compression data plane API.
    *
    * @description
    *      This function triggers processing of previously enqueed requests on the
    *      referenced instance.
    *
    *
    * @context
    *      Will not sleep. It can be executed in a context that does not
    *      permit sleeping.
    *
    * @sideEffects
    *      None
    * @blocking
    *      No
    * @reentrant
    *      No
    * @threadSafe
    *      No
    *
    * @param[in] dcInstance        Instance to which the requests will be
    *                                  submitted.
    *
    * @retval CPA_STATUS_SUCCESS        Function executed successfully.
    * @retval CPA_STATUS_FAIL           Function failed.
    * @retval CPA_STATUS_RETRY          Resubmit the request.
    * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in.
    * @retval CPA_STATUS_RESTARTING     API implementation is restarting. Resubmit
    *                                   the request.
    * @retval CPA_STATUS_UNSUPPORTED    Function is not supported.
    *
    * @pre
    *      The component has been initialized via @ref cpaDcStartInstance function.
    *      A compression session has been previously setup using the
    *      @ref cpaDcDpInitSession function call.
    *
    * @post
    *      None
    *
    * @see
    *      cpaDcDpEnqueueOp, cpaDcDpEnqueueOpBatch
    *****************************************************************************/
   CpaStatus
   cpaDcDpPerformOpNow(CpaInstanceHandle dcInstance);
   
   
   
   #ifdef __cplusplus
   } /* close the extern "C" { */
   #endif
   
   #endif /* CPA_DC_DP_H */
   

Cache object: c12db72e2030ed388a1276c10ac5c471