synx.h

Go to the documentation of this file.

// Copyright (c) 2019-2024 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.


#ifndef SYNX_H
#define SYNX_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

    // Entry Point
    #if defined (_WIN32)
    #define SYNX_DLL_EXPORT            __declspec(dllexport)
    #define SYNX_DLL_IMPORT            __declspec(dllimport)
    #elif defined(__GNUC__)
    #define SYNX_DLL_EXPORT            __attribute((visibility("default")))
    #define SYNX_DLL_IMPORT
    #endif

    #if defined(SYNX_LIB_EXPORT)
    #define SYNX_API                   SYNX_DLL_EXPORT
    #define SYNX_INLINE                inline
    #else
    #define SYNX_INLINE
    #define SYNX_API                   SYNX_DLL_IMPORT
    #endif


#define SYNX_DEVICE_NAME "synx_device"



#define SYNX_SUCCESS      0
#define SYNX_NOMEM        ENOMEM
#define SYNX_NOSUPPORT    EPERM
#define SYNX_NOPERM       EPERM
#define SYNX_TIMEOUT      ETIMEDOUT
#define SYNX_ALREADY      EALREADY
#define SYNX_NOENT        ENOENT
#define SYNX_INVALID      EINVAL
#define SYNX_ERROR_FAILED EPERM

#define SYNX_NO_TIMEOUT        ((uint64_t)-1)

#define SYNX_INVALID_HANDLE 0

struct synx_session {
    uint32_t type;
    void     *client;
};

enum synx_client_id {
    SYNX_CLIENT_NATIVE = 0,
    SYNX_CLIENT_MAX,
};

enum synx_init_flags {
    SYNX_INIT_DEFAULT = 0x00,
    SYNX_INIT_MAX     = 0x01,
};

struct synx_initialization_params {
    const char             *name;
    enum synx_client_id    id;
    enum synx_init_flags   flags;
};

enum synx_create_flags {
    SYNX_CREATE_LOCAL_FENCE  = 0x01,
    SYNX_CREATE_GLOBAL_FENCE = 0x02,
    SYNX_CREATE_DMA_FENCE    = 0x04,
    SYNX_CREATE_CSL_FENCE    = 0x08,
};

struct synx_create_params {
    const char             *name;
    uint32_t               *h_synx;
    void                   *fence;
    enum synx_create_flags flags;
};

typedef void (*synx_user_callback)(uint32_t h_synx, int status, void *data);

struct synx_callback_params {
    uint32_t           h_synx;
    synx_user_callback cb_func;
    void               *userdata;
    synx_user_callback cancel_cb_func;
    uint64_t           timeout_ms;
};

enum synx_signal_status {
    SYNX_STATE_SIGNALED_SUCCESS = 2,
    SYNX_STATE_SIGNALED_CANCEL  = 4,
    SYNX_STATE_SIGNALED_MAX     = 64,
};


enum synx_import_flags {
    SYNX_IMPORT_LOCAL_FENCE  = 0x01,
    SYNX_IMPORT_GLOBAL_FENCE = 0x02,
    SYNX_IMPORT_SYNX_FENCE   = 0x04,
    SYNX_IMPORT_DMA_FENCE    = 0x08,
    SYNX_IMPORT_EX_RELEASE   = 0x10,
};

enum synx_import_type {
    SYNX_IMPORT_INDV_PARAMS = 0x01,
    SYNX_IMPORT_ARR_PARAMS  = 0x02,
};

struct synx_import_indv_params {
    uint32_t               *new_h_synx;
    enum synx_import_flags flags;
    void                   *fence;
};

struct synx_import_arr_params {
    struct synx_import_indv_params *list;
    uint32_t                        num_fences;
};

struct synx_import_params {
    enum synx_import_type type;
    union {
        struct synx_import_indv_params indv;
        struct synx_import_arr_params  arr;
    };
};

enum synx_merge_flags {
    SYNX_MERGE_LOCAL_FENCE   = 0x01,
    SYNX_MERGE_GLOBAL_FENCE  = 0x02,
    SYNX_MERGE_NOTIFY_ON_ALL = 0x04,
    SYNX_MERGE_NOTIFY_ON_ANY = 0x08,
};

/*
 * struct synx_merge_params - Synx merge parameters
 *
 * @h_synxs      : Pointer to a array of synx handles to be merged.
 * @flags        : Merge flags.
 * @num_objs     : Number of synx handles to be merged.
 * @h_merged_obj : Pointer to synx object handle passed by client.
 *                 Created merged synx handle filled by function.
 */
struct synx_merge_params {
    uint32_t              *h_synxs;
    enum synx_merge_flags flags;
    uint32_t              num_objs;
    uint32_t              *h_merged_obj;
};

/*
 * enum synx_status - Synx status definitions.
 *
 * @SYNX_STATUS_INVALID             : Invalid synx object.
 * @SYNX_STATUS_UNSIGNALED          : Synx object has not been signaled.
 * @SYNX_STATUS_SIGNALED_SUCCESS    : Synx object has been signaled.
 * @SYNX_STATUS_SIGNALED_ERROR      : Synx object signaled with error.
 * @SYNX_STATUS_SIGNALED_CANCEL     : Synx object signalling cancelled.
 * @SYNX_STATUS_SIGNALED_EXTERNAL   : Synx object signaled by external dma client.
 * @SYNX_STATUS_SIGNALED_SSR        : Synx object signaled with SSR.
 * @SYNX_STATUS_TIMEOUT             : Callback status for synx object
 *                                    in case of timeout.
 */
enum synx_status {
    SYNX_STATUS_INVALID = 0,
    SYNX_STATUS_UNSIGNALED,
    SYNX_STATUS_SIGNALED_SUCCESS,
    SYNX_STATUS_SIGNALED_ERROR,
    SYNX_STATUS_SIGNALED_CANCEL,
    SYNX_STATUS_SIGNALED_EXTERNAL,
    SYNX_STATUS_SIGNALED_SSR,
    SYNX_STATUS_TIMEOUT,
};


/* Userspace APIs */

SYNX_API struct synx_session *synx_initialize(struct synx_initialization_params *pParam);

SYNX_API int32_t synx_uninitialize(struct synx_session *pSession);

SYNX_API int32_t synx_create(struct synx_session *pSession, struct synx_create_params *pParam);

SYNX_API int32_t synx_get_status(struct synx_session *pSession, uint32_t hSynx);

SYNX_API int32_t synx_release(struct synx_session *pSession, uint32_t hSynx);

SYNX_API int32_t synx_signal(struct synx_session *pSession, uint32_t hSynx, enum synx_signal_status state);

SYNX_API int32_t synx_wait(struct synx_session *pSession, uint32_t hSynx, uint64_t timeout_ms);

SYNX_API int32_t synx_async_wait(struct synx_session *pSession, struct synx_callback_params *pParams);

SYNX_API int32_t synx_cancel_async_wait(struct synx_session *pSession, struct synx_callback_params *pParams);

SYNX_API int32_t synx_merge( struct synx_session *pSession, struct synx_merge_params *pParams);

SYNX_API int32_t synx_import(struct synx_session *pSession, struct synx_import_params *pParams);

SYNX_API int32_t synx_get_fd(struct synx_session *pSession, uint32_t hSynx);

#ifdef __cplusplus
}
#endif // __cplusplus

#endif // SYNX_H