iss_sensors.h

Go to the documentation of this file.

/*
 *
 * Copyright (c) 2020 Texas Instruments Incorporated
 *
 * All rights reserved not granted herein.
 *
 * Limited License.
 *
 * Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
 * license under copyrights and patents it now or hereafter owns or controls to make,
 * have made, use, import, offer to sell and sell ("Utilize") this software subject to the
 * terms herein.  With respect to the foregoing patent license, such license is granted
 * solely to the extent that any such patent is necessary to Utilize the software alone.
 * The patent license shall not apply to any combinations which include this software,
 * other than combinations with devices manufactured by or for TI ("TI Devices").
 * No hardware patent is licensed hereunder.
 *
 * Redistributions must preserve existing copyright notices and reproduce this license
 * (including the above copyright notice and the disclaimer and (if applicable) source
 * code license limitations below) in the documentation and/or other materials provided
 * with the distribution
 *
 * Redistribution and use in binary form, without modification, are permitted provided
 * that the following conditions are met:
 *
 * *       No reverse engineering, decompilation, or disassembly of this software is
 * permitted with respect to any software provided in binary form.
 *
 * *       any redistribution and use are licensed by TI for use only with TI Devices.
 *
 * *       Nothing shall obligate TI to provide you with source code for the software
 * licensed and provided to you in object code.
 *
 * If software source code is provided to you, modification and redistribution of the
 * source code are permitted provided that the following conditions are met:
 *
 * *       any redistribution and use of the source code, including any resulting derivative
 * works, are licensed by TI for use only with TI Devices.
 *
 * *       any redistribution and use of any object code compiled from the source code
 * and any resulting derivative works, are licensed by TI for use only with TI Devices.
 *
 * Neither the name of Texas Instruments Incorporated nor the names of its suppliers
 *
 * may be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * DISCLAIMER.
 *
 * THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "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 TI AND TI'S LICENSORS 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.
 *
 */
#ifndef ISS_SENSORS_H_
#define ISS_SENSORS_H_

#include "TI/tivx_ext_raw_image.h"

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>

/*******************************************************************************
 *  Include files
 *******************************************************************************
 */

/*******************************************************************************
 *  Defines
 *******************************************************************************
 */

/* FPD-Link initialization using B7 implementation */
// #define B7_IMPLEMENTATION

#define SENSOR_I2C_TIMEOUT    (5000U)

typedef enum
{
    IM_SENSOR_CMD_ENUMERATE = 0,
    IM_SENSOR_CMD_QUERY,
    IM_SENSOR_CMD_PWRON,
    IM_SENSOR_CMD_CONFIG,
    IM_SENSOR_CMD_STREAM_ON,
    IM_SENSOR_CMD_STREAM_OFF,
    IM_SENSOR_CMD_PWROFF,
    IM_SENSOR_CMD_CTL,
    IM_SENSOR_CMD_DEBUG,
    IM_SENSOR_CMD_DETECT,
    IM_SENSOR_CMD_D3_USER_I2C,
    IM_SENSOR_CMD_DETECT_PERSONALITY_BOARD,
    IM_SENSOR_CMD_CTL_MAX,
    IM_SENSOR_CMD_CTL_FORCE32BITS          = 0x7FFFFFFF
}IMAGE_SENSOR_COMMAND;

typedef enum
{
    IMAGE_SERDES_FPD_LINK_3 = 0,
    IMAGE_SERDES_FPD_LINK_4,
    IMAGE_SERDES_FPD_LINK_MAX,
    IMAGE_SERDES_FPD_LINK_FORCE32BITS           = 0x7FFFFFFF
}IMAGE_SERDES_FPD_LINK;


typedef enum
{
    IMAGE_SENSOR_CTRLCMD_GETEXPPRG = 0,
    IMAGE_SENSOR_CTRLCMD_GETWBCFG,
    IMAGE_SENSOR_CTRLCMD_INIT_AEWB_CFG,
    IMAGE_SENSOR_CTRLCMD_SETEXPGAIN,
    IMAGE_SENSOR_CTRLCMD_GETEXPGAIN,
    IMAGE_SENSOR_CTRLCMD_SETWBGAIN,
    IMAGE_SENSOR_CTRLCMD_GETWBGAIN,
    IMAGE_SENSOR_CTRLCMD_DEBUG,
    IMAGE_SENSOR_CTRLCMD_READ_SENSOR_REG,
    IMAGE_SENSOR_CTRLCMD_WRITE_SENSOR_REG,
    IMAGE_SENSOR_CTRLCMD_READ_SENSOR_REG_IMMEDIATE_I2C,
    IMAGE_SENSOR_CTRLCMD_WRITE_SENSOR_REG_IMMEDIATE_I2C,
    IMAGE_SENSOR_CTRLCMD_MAX,
    IMAGE_SENSOR_CTRLCMD_FORCE32BITS          = 0x7FFFFFFF
}IMAGE_SENSOR_CTRLCMD;


#define IMAGE_SENSOR_REMOTE_SERVICE_NAME  "com.ti.image_sensor"
#define CMD_PARAM_SIZE 384

/* Maximum number of channels supported */
#if defined(SOC_J784S4) || defined(SOC_J742S2)
#define ISS_SENSORS_MAX_CHANNEL                 (12U)
#else
#define ISS_SENSORS_MAX_CHANNEL                 (8U)
#endif

/* Max characters in the sensor name */
#define ISS_SENSORS_MAX_NAME                    (32U)

/* Supports Sensor's name */
#define SENSOR_SONY_IMX390_UB953_D3                 "IMX390-UB953_D3"
#define SENSOR_SONY_IMX728_UB971_SONY               "IMX728-UB971_SONY"
#define SENSOR_ONSEMI_AR0233_UB953_MARS             "AR0233-UB953_MARS"
#define SENSOR_ONSEMI_AR0820_UB953_LI               "AR0820-UB953_LI"
#define UB9XX_RAW_TESTPAT                           "UB9xxx_RAW12_TESTPATTERN"
#define UB96X_TESTPATTERN_UYVY                      "UB96x_UYVY_TESTPATTERN"
#define GW_AR0233_UYVY                              "GW_AR0233_UYVY"
#define SENSOR_OV2312_UB953_LI                      "OV2312-UB953_LI"
#define SENSOR_SONY_IMX390_UB953_DISCOVERY_NARROW   "IMX390-UB953-DISCOVERY-NARROW"
#define SENSOR_SONY_IMX390_UB953_DISCOVERY_MID      "IMX390-UB953-DISCOVERY-MID"
#define SENSOR_SONY_IMX390_UB953_DISCOVERY_WIDE     "IMX390-UB953-DISCOVERY-WIDE"

/* Defines ported from PDK for devices on MCU_PLUS_SDK */
#if defined (MCU_PLUS_SDK)

#define BOARD_I2C_REG_ADDR_MSB_FIRST                        (0x0U)

#define I2C_400kHz                                          I2C_400KHZ

#define BOARD_CSI_INST_0             ((uint32_t) 0x0U)

#define BOARD_CSI_INST_1             ((uint32_t) 0x1U)

#define BOARD_CSI_INST_2             ((uint32_t) 0x2U)
/* @} */

#define BOARD_FPD_9702_CSI2_DES_HUB1                            (0U)
#define BOARD_FPD_9702_CSI2_DES_HUB2                            (1U)
#define BOARD_FPD_9702_CSI2_DES_HUB3                            (2U)

/* Board detect ID for Fusion2 */
#define BOARD_ID_FUSION2         (0x2U)

int32_t Board_i2c16BitRegRd(void   *handle,
                                 uint32_t slaveAddr,
                                 uint16_t regAddr,
                                 uint8_t *regData,
                                 uint8_t numOfBytes,
                                 uint8_t byteOrdSel,
                                 uint32_t i2cTimeout);

void Board_fpdUb9702GetI2CAddr(uint8_t *i2cAddr,
                             uint32_t hubInstance);
#endif /* MCU_PLUS_SDK */

/*******************************************************************************
 *  Data structure's
 *******************************************************************************
 */

typedef enum
{
    ISS_SENSOR_FEATURE_HFLIP                = 0x1,
    ISS_SENSOR_FEATURE_VFLIP                = 0x2,
    ISS_SENSOR_FEATURE_EMBEDDED_DATA        = 0x4,
    ISS_SENSOR_FEATURE_MANUAL_EXPOSURE      = 0x8,
    ISS_SENSOR_FEATURE_MANUAL_GAIN          = 0x10,
    ISS_SENSOR_FEATURE_LINEAR_MODE          = 0x20,
    ISS_SENSOR_FEATURE_COMB_COMP_WDR_MODE    = 0x40,
    ISS_SENSOR_FEATURE_TWO_FRAME_WDR_MODE    = 0x80,
    ISS_SENSOR_FEATURE_DCC_SUPPORTED        = 0x100,
    ISS_SENSOR_FEATURE_CFG_UC1               = 0x200,
    ISS_SENSOR_FEATURE_CFG_UC2               = 0x400,
    ISS_SENSOR_MAX_FEATURES                 = 0x800,
    ISS_SENSOR_FEATURE_FORCE32BITS          = 0x7FFFFFFF
} IssSensor_Features;


typedef enum
{
    ISS_SENSOR_EXPOSURE_LONG,
    ISS_SENSOR_EXPOSURE_SHORT,
    ISS_SENSOR_EXPOSURE_VSHORT,
    ISS_SENSOR_MAX_EXPOSURE,
    ISS_SENSOR_EXPOSURE_FORCE32BITS = 0x7FFFFFFF
} IssSensor_Exposures;

typedef enum {
    ALGORITHMS_ISS_AEWB_MODE_AWB        = 0,
    ALGORITHMS_ISS_AEWB_MODE_AE         = 1,
    ALGORITHMS_ISS_AEWB_MODE_AEWB       = 2,
    ALGORITHMS_ISS_AEWB_MODE_NONE       = 3,
    ALGORITHMS_ISS_AEWB_MODE_MAX        = 4,
    ALGORITHMS_ISS_AEWB_MODE_FORCE32BITS = 0x7FFFFFFF
} AlgItt_IssAewbMode;

typedef enum {
    ALGORITHMS_ISS_AE_AUTO        = 0,
    ALGORITHMS_ISS_AE_MANUAL        = 1,
    ALGORITHMS_ISS_AE_DISABLED        = 2
} AlgItt_IssAeMode;

typedef enum {
    ALGORITHMS_ISS_AWB_AUTO        = 0,
    ALGORITHMS_ISS_AWB_MANUAL      = 1,
    ALGORITHMS_ISS_AWB_DISABLED    = 2
} AlgItt_IssAwbMode;


typedef struct
{
    uint32_t totalWidth, totalHeight;
    struct {
        uint32_t startx, starty;
        uint32_t width, height;
    } info[ISS_SENSOR_MAX_EXPOSURE];
} IssSensor_LineInterleavedExpFrmInfo;

typedef struct
{
    uint16_t nRegAddr;
    uint16_t nRegValue;
    uint32_t nDelay;
} I2cParams;


typedef struct
{
    uint32_t chId;
    uint32_t expRatio;
    uint32_t exposureTime[ISS_SENSOR_MAX_EXPOSURE];
    uint32_t analogGain[ISS_SENSOR_MAX_EXPOSURE];
} IssSensor_ExposureParams;


typedef struct
{
    uint32_t chId;
    uint32_t rGain[ISS_SENSOR_MAX_EXPOSURE];
    uint32_t gGain[ISS_SENSOR_MAX_EXPOSURE];
    uint32_t bGain[ISS_SENSOR_MAX_EXPOSURE];
    uint32_t colorTemp[ISS_SENSOR_MAX_EXPOSURE];
}IssSensor_WhiteBalanceParams;


typedef struct
{
    uint32_t chId;
    uint8_t *pDccCfg;
    uint32_t dccCfgSize;
} IssSensor_DccParams;

typedef struct
{
    IMAGE_SERDES_FPD_LINK         fpdLink;

    uint8_t                     senI2cAddr;

    uint8_t                     serI2cAddr;
} IssSensor_ModuleParams;


typedef struct
{
    tivx_raw_image_create_params_t        raw_params;
    uint32_t                              features;
    uint32_t                              aewbMode;
    uint32_t                          fps;
    uint32_t numDataLanes;
    uint32_t dataLanesMap[4];
    uint32_t dataLanesPolarity[4];
    uint32_t csi_laneBandSpeed;      
} IssSensor_Info;


typedef struct
{
    char                                name[ISS_SENSORS_MAX_NAME];
    uint16_t                            i2cInstId;
    uint8_t                             i2cAddrSensor[ISS_SENSORS_MAX_CHANNEL];
    uint8_t                             i2cAddrSer[ISS_SENSORS_MAX_CHANNEL];
    // uint8_t                             i2cAddrMisc[ISS_SENSORS_MAX_CHANNEL];
    IssSensor_Info                      sensorInfo;
#if defined(B7_IMPLEMENTATION)
    IssSensor_ModuleParams              moduleInfo;
#endif
    uint32_t                            num_channels;
    uint32_t                            dccId;
} IssSensor_CreateParams;

/*******************************************************************************
 *  Defines
 *******************************************************************************
 */

/* Maximum amount of sensors allowed to be connected via Fusion board
(8 on Fusion1, 12 on Fusion2) */
#define ISS_SENSORS_MAX_SENSOR_INSTANCES        (12U)
#define ISS_SENSORS_MAX_SUPPORTED_SENSOR        ISS_SENSORS_MAX_SENSOR_INSTANCES

/* Maximum amount of sensor handles allowed to be registered to the framework
   Memory can handle up to 15 handles */
#define ISS_SENSORS_MAX_SENSOR_HANDLES          (12U)


#define DEFAULT_TARGET_BRIGHTNESS_MIN                   40
#define DEFAULT_TARGET_BRIGHTNESS_MAX                   50
#define DEFAULT_TARGET_BRIGHTNESS                       45
#define DEFAULT_TARGET_THRESHOLD                        5
#define DEFAULT_EXPOSURE_TIME                           1
#define DEFAULT_ENABLE_BLC                              0


/* 8-bit GPIO Expander 5 */
#define TCA6408_I2C_ADDR_1          0x20
#define TCA6408_I2C_ADDR_2          0x21
#define TCA6408_CONFIG_REG          0x03

/* Register values for port select register (0x4C) to read and write from
    specified port:
FPD3 RX Port 0  |   FPD3 RX Port 1  |   FPD3 RX Port 2  |   FPD3 RX Port 3
R: 0x4C[5:4]=00 |   R: 0x4C[5:4]=01 |   R: 0x4C[5:4]=10 |   R: 0x4C[5:4]=11
W: 0x4C[0]=1    |   W: 0x4C[1]=1    |   W: 0x4C[2]=1    |   W: 0x4C[3]=1  */
#define DES_PORT_SEL_0      0x01
#define DES_PORT_SEL_1      0x12
#define DES_PORT_SEL_2      0x24
#define DES_PORT_SEL_3      0x38


/*******************************************************************************
 *  Data Structures
 *******************************************************************************
 */

typedef struct
{
    uint8_t pol;
    uint8_t position;
} IssCapture_CmplxIoLaneCfg;


typedef struct
{
    uint8_t                                sensorBroadcast;
    uint8_t                                enableFsin;
    uint8_t                                numCamerasStreaming;
} IssSensorIntfParams;


typedef struct
{
    I2cParams    * desCfgPreScript;
    I2cParams    * serCfgPreScript;
    I2cParams    * sensorCfgPreScript;
    I2cParams    * desCfgPostScript;
    I2cParams    * serCfgPostScript;
    I2cParams    * sensorCfgPostScript;
} IssSensorConfig;

typedef struct {
    uint32_t min;
    uint32_t max;
} IssAeRange;


#define MAX_AE_DYN_PARAMS       (10U)

typedef struct {
    IssAeRange exposureTimeRange[MAX_AE_DYN_PARAMS];
    IssAeRange analogGainRange[MAX_AE_DYN_PARAMS];
    IssAeRange digitalGainRange[MAX_AE_DYN_PARAMS];
    uint32_t                     numAeDynParams;
    IssAeRange targetBrightnessRange;
    uint32_t                     targetBrightness;
    uint32_t                     threshold;
    uint32_t                     exposureTimeStepSize;
    uint32_t                     enableBlc;
} IssAeDynamicParams;


typedef struct {
    IssAeRange redGainRange;
    IssAeRange blueGainRange;
    IssAeRange greenGainRange;
    uint32_t   sensor_pre_gain;
} IssAwbDynamicParams;

typedef int32_t (*IssSensor_ProbeFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*IssSensor_ConfigFxn) (uint32_t chId, void *pSensorHdl, uint32_t sensor_features_requested);

typedef int32_t (*IssSensor_StreamOnFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*IssSensor_StreamOffFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*IssSensor_PowerOnFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*IssSensor_PowerOffFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*IssSensor_SetAeParamsFxn) (void *pSensorHdl, uint32_t chId, IssSensor_ExposureParams *pExpPrms);

typedef int32_t (*IssSensor_GetDccParamsFxn) (uint32_t chId, void *pSensorHdl, IssSensor_DccParams *pDccPrms);

typedef int32_t (*IssSensor_GetExpParamsFxn) (uint32_t chId, void *pSensorHdl, IssSensor_ExposureParams *pExpPrms);

typedef void (*IssSensor_InitAewbConfigFxn) (uint32_t chId, void *pSensorHdl);

typedef void (*IssSensor_GetIspConfigFxn) (uint32_t chId, void *pSensorHdl);

typedef void (*IssSensor_DeinitFxn) (uint32_t chId, void *pSensorHdl);

typedef int32_t (*I2cRegReadWriteFxn) (uint32_t chId, void *pSensorHdl, uint32_t readWriteFlag, I2cParams *pReg);

typedef int32_t (*IssSensor_GetExpPrgFxn) (uint32_t chId, void *pSensorHdl, IssAeDynamicParams *p_ae_dynPrms);

typedef int32_t (*IssSensor_GetWbConfigFxn) (uint32_t chId, void *pSensorHdl, IssAwbDynamicParams *p_awb_dynPrms);


typedef int32_t (*IssSensor_SetAwbParamsFxn) (void *pSensorHdl, uint32_t chId, IssSensor_WhiteBalanceParams *pWbPrms);

typedef int32_t (*IssSensor_GetAwbParamsFxn) (uint32_t chId, void *pSensorHdl, IssSensor_WhiteBalanceParams *pWbPrms);

struct IssSensorFxns_t {
    IssSensor_ProbeFxn               probe;
    IssSensor_ConfigFxn              config;
    IssSensor_StreamOnFxn            streamOn;
    IssSensor_StreamOffFxn           streamOff;
    IssSensor_PowerOnFxn             powerOn;
    IssSensor_PowerOffFxn            powerOff;
    IssSensor_GetExpParamsFxn        getAeParams;
    IssSensor_SetAeParamsFxn         setAeParams;
    IssSensor_GetDccParamsFxn        getDccParams;
    IssSensor_InitAewbConfigFxn      initAewbConfig;
    IssSensor_GetIspConfigFxn        getIspConfig;
    I2cRegReadWriteFxn                readWriteReg;
    IssSensor_GetExpPrgFxn           getExpPrg;
    IssSensor_DeinitFxn                deinit;
    IssSensor_GetWbConfigFxn         getWbCfg;
    IssSensor_SetAwbParamsFxn        setAwbParams;
    IssSensor_GetAwbParamsFxn        getAwbParams;
};
/* Forward Declaration of Sensor Params */
typedef struct IssSensorFxns_t IssSensorFxns;


// typedef int32_t (*IssSerDes_ProbeFxn)(uint32_t chId, void *pSensorHdl);

// typedef int32_t (*IssSerDes_ConfigFxn)(uint32_t chId, void *pSensorHdl);

// typedef int32_t (*IssSerDes_EnableCSIFxn)(uint32_t chId, void *pSensorHdl);

// typedef int32_t (*IssSerDes_DisableCSIFxn)(uint32_t chId, void *pSensorHdl);

// typedef int32_t (*IssSerDes_SelectTypeFxn)(uint32_t chId, void *pSensorHdl, uint32_t type);

// struct IssSerDesFxns_t {
//     IssSerDes_ProbeFxn              probe;
//     IssSerDes_ConfigFxn             config;
//     IssSerDes_EnableCSIFxn          enableCSI;
//     IssSerDes_DisableCSIFxn         disableCSI;
//     IssSerDes_SelectTypeFxn         selectType;
// };
// typedef struct IssSerDesFxns_t IssSerDesFxns;

typedef struct
{
    uint32_t                      isUsed;
    IssSensor_CreateParams      * createPrms;
    IssSensorFxns          * sensorFxns;
    IssSensorIntfParams      *    sensorIntfPrms;
    // IssSerDesFxns           * desFxns;
    // IssSerDesFxns           * serFxns;
} IssSensors_Handle;


/*******************************************************************************
 *  Functions Declarations
 *******************************************************************************
 * \ingroup group_vision_function_imaging_sensordrv
 */


int32_t IssSensor_Init();

int32_t IssSensor_DeInit();

int32_t IssSensor_Register(IssSensors_Handle *pSensorPrms);


int32_t IssSensor_GetSensorInfo(char * name, IssSensor_CreateParams *pCreatePrms);

IssSensors_Handle *IssSensor_getSensorHandleFromName(char *name);

#ifndef DEPRECATED
#define IssSensor_GetSensorHandle IssSensor_getSensorHandleFromName
#endif /* DEPRECATED */

IssSensors_Handle * IssSensor_GetSensorHandle(char * name);

void* IssSensor_Create(char * name);

int32_t IssSensor_Control(void* handle, uint32_t cmd, void* cmdArgs,
    void* cmdRetArgs);

int32_t IssSensor_Start(void* handle, uint32_t chId);

int32_t IssSensor_Stop(void* handle, uint32_t chId);

int32_t IssSensor_Delete(void* handle);

int32_t IssSensor_cfgDesScript(I2cParams *script, int8_t ub960InstanceId);

int32_t ub953_cfgScript(uint8_t  i2cInstId, uint8_t  i2cAddr, I2cParams *script);

// IssSensors_Handle * getSensorHandleFromName(char *name);

int32_t IssSensor_PowerOn(void* handle, uint32_t chMask);


int32_t IssSensor_PowerOff(void* handle, uint32_t chId);

int32_t IssSensor_Config(void* handle, uint32_t chId, uint32_t feat);

int32_t IssSensor_SetAeParams(void *handle, uint32_t chId, IssSensor_ExposureParams *pExpPrms);

int32_t IssSensor_SetAwbParams(void *handle, uint32_t chId, IssSensor_WhiteBalanceParams *pWbPrms);

int32_t enableUB960Broadcast(int8_t ub960InstanceId);
int32_t disableUB960Broadcast(int8_t ub960InstanceId);
int32_t UB960_SelectPort(uint32_t chId);
int32_t UB960_SetAlias(uint32_t chId, uint8_t slot,  uint8_t phy_i2c_addr_7bit, uint8_t alias_i2c_addr_7bit);
int32_t UB960_SetSerAlias(uint32_t chId, uint8_t alias_i2c_addr_7bit);
int32_t UB960_SetSensorAlias(uint32_t chId, uint8_t sensor_phy_i2c_addr_7bit, uint8_t ser_alias_i2c_addr_7bit);


int32_t enableUB960Streaming(uint32_t chId);

int32_t disableUB960Streaming(uint32_t chId);


int8_t getDeserializerInstIdFromChId(uint32_t chId);

int32_t powerOffDeserializers(void);


#ifndef DEPRECATED

int32_t IssSensor_GetSensorInfoFromDccId(uint32_t dccId, IssSensor_Info *pInfo);

#endif /* DEPRECATED */

#endif /* End of ISS_SENSORS_H_*/