nvsciipc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2023, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
 
#ifndef INCLUDED_NVSCIIPC_H
#define INCLUDED_NVSCIIPC_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <stddef.h>
#include <nvscierror.h>
#include <nvscievent.h>
 
/* use constant global version variable instead of macro for consistency with
 * version check API of existing NvSci family
 */
 
static const uint32_t NvSciIpcMajorVersion = 1U;
 
static const uint32_t NvSciIpcMinorVersion = 2U;
 
/*******************************************************************/
/************************ DATA TYPES *******************************/
/*******************************************************************/
 
typedef uint64_t NvSciIpcEndpoint;
 
typedef struct NvSciIpcEndpointInfo NvSciIpcEndpointInfo;
 
struct NvSciIpcEndpointInfo {
    uint32_t nframes;
    uint32_t frame_size;
};
 
#define NVSCIIPC_MAX_ENDPOINT_NAME   64U
 
/* NvSciIPC Event type */
#define NV_SCI_IPC_EVENT_READ           0x01U
 
#define NV_SCI_IPC_EVENT_WRITE          0x02U
 
#define NV_SCI_IPC_EVENT_CONN_EST       0x04U
 
#define NV_SCI_IPC_EVENT_CONN_RESET     0x08U
 
#define NV_SCI_IPC_EVENT_WRITE_EMPTY    0x10U
 
#define NV_SCI_IPC_EVENT_CONN_EST_ALL (NV_SCI_IPC_EVENT_CONN_EST | \
    NV_SCI_IPC_EVENT_WRITE | NV_SCI_IPC_EVENT_WRITE_EMPTY | \
    NV_SCI_IPC_EVENT_READ)
 
#define NVSCIIPC_INFINITE_WAIT -1LL
 
/*******************************************************************/
/********************* FUNCTION TYPES ******************************/
/*******************************************************************/
 
NvSciError NvSciIpcInit(void);
 
void NvSciIpcDeinit(void);
 
NvSciError NvSciIpcOpenEndpoint(const char *endpoint, NvSciIpcEndpoint *handle);
 
NvSciError NvSciIpcOpenEndpointWithEventService(const char *endpoint,
    NvSciIpcEndpoint *handle, NvSciEventService *eventService);
 
NvSciError NvSciIpcGetEventNotifier(NvSciIpcEndpoint handle,
               NvSciEventNotifier **eventNotifier);
 
void NvSciIpcCloseEndpoint(NvSciIpcEndpoint handle);
 
NvSciError NvSciIpcCloseEndpointSafe(NvSciIpcEndpoint handle, bool clear);
 
void NvSciIpcResetEndpoint(NvSciIpcEndpoint handle);
 
NvSciError NvSciIpcResetEndpointSafe(NvSciIpcEndpoint handle);
 
NvSciError NvSciIpcRead(NvSciIpcEndpoint handle, void *buf, size_t size,
    int32_t *bytes);
 
NvSciError NvSciIpcReadSafe(NvSciIpcEndpoint handle, void *buf, uint32_t size,
    uint32_t *bytes);
 
NvSciError NvSciIpcReadGetNextFrame(NvSciIpcEndpoint handle,
    const volatile void **buf);
 
NvSciError NvSciIpcReadAdvance(NvSciIpcEndpoint handle);
 
NvSciError NvSciIpcWrite(NvSciIpcEndpoint handle, const void *buf, size_t size,
    int32_t *bytes);
 
NvSciError NvSciIpcWriteSafe(NvSciIpcEndpoint handle, const void *buf,
    uint32_t size, uint32_t *bytes);
 
NvSciError NvSciIpcWriteGetNextFrame(NvSciIpcEndpoint handle,
    volatile void **buf);
 
NvSciError NvSciIpcWriteAdvance(NvSciIpcEndpoint handle);
 
NvSciError NvSciIpcGetEndpointInfo(NvSciIpcEndpoint handle,
                NvSciIpcEndpointInfo *info);
 
#ifndef __QNX__
 
NvSciError NvSciIpcGetLinuxEventFd(NvSciIpcEndpoint handle, int32_t *fd);
#endif /* !__QNX__ */
 
NvSciError NvSciIpcGetEvent(NvSciIpcEndpoint handle, uint32_t *events);
 
NvSciError NvSciIpcGetEventSafe(NvSciIpcEndpoint handle, uint32_t *events);
 
#if defined(__QNX__)
 
int32_t NvSciIpcWaitEventQnx(int chid, int64_t microseconds, uint32_t bytes,
    void *pulse);
 
NvSciError NvSciIpcSetQnxPulseParam(NvSciIpcEndpoint handle,
    int32_t coid, int16_t pulsePriority, int16_t pulseCode,
    void *pulseValue);
 
NvSciError NvSciIpcSetQnxPulseParamSafe(NvSciIpcEndpoint handle,
    int32_t coid, int16_t pulsePriority, int16_t pulseCode);
 
 
NvSciError NvSciIpcInspectEventQnx(int32_t chid, uint16_t numEvents,
    uint32_t epCount, NvSciIpcEndpoint **epHandleArray);
#endif /* __QNX__ */
 
/*
 * \brief Checks if loaded NvSciIpc library version is compatible with
 * the version the application was compiled against.
 *
 * This function checks loaded NvSciIpc library version with input NvSciIpc
 * library version and sets output variable true provided major version of the
 * loaded library is same as @a majorVer and minor version of the
 * loaded library is not less than @a minorVer, else sets output to false
 *
 * @param[in]  majorVer build major version.
 * @param[in]  minorVer build minor version.
 * @param[out] isCompatible boolean value stating if loaded NvSciIpc library
 *             is compatible or not.
 *
 * @return ::NvSciError, the completion code of the operation:
 * - ::NvSciError_Success if successful.
 * - ::NvSciError_BadParameter if any of the following occurs:
 *      - @a isCompatible is NULL
 *
 * @pre None
 *
 * @usage
 * - Allowed context for the API call
 *   - Interrupt: No
 *   - Signal handler: No
 *   - Thread-safe: Yes
 *   - Async/Sync: Sync
 * - Required Privileges(QNX): None
 * - API Group
 *   - Init: Yes
 *   - Runtime: Yes
 *   - De-Init: Yes
 */
NvSciError NvSciIpcCheckVersionCompatibility(
    uint32_t majorVer,
    uint32_t minorVer,
    bool* isCompatible);
 
#ifdef __cplusplus
}
#endif
#endif /* INCLUDED_NVSCIIPC_H */