devblk_cdi.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015-2022, NVIDIA CORPORATION.  All rights reserved. All
 * information contained herein is proprietary and confidential to NVIDIA
 * Corporation.  Any use, reproduction, or disclosure without the written
 * permission of NVIDIA Corporation is prohibited.
 */
 
#ifndef DEVBLK_CDI_H
#define DEVBLK_CDI_H
 
#include "nvmedia_core.h"
#include "NvSIPLCapStructs.h"
#include "NvSIPLCDICommon.h"
 
#ifndef __cplusplus
#include <stdbool.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DEVBLK_CDI_SIMULATOR_ADDRESS   0xFF1U
 
#define RDEV_CFG_I2C_BITS           8
 
#define RDEV_CFG_CSI_BITS           (RDEV_CFG_I2C_BITS + 8)
 
#define RDEV_CFG_SLV_BIT            (RDEV_CFG_CSI_BITS + 1)
 
#define CDI_RDEV_CFG(csi, i2c)   (((uint32_t)(csi) << (uint32_t)RDEV_CFG_I2C_BITS) | (i2c))
 
#define CDI_RDEV_CFG_EX(csi, i2c, disPwrCtrl) \
         ((i2c & 0xffU) | \
          ((uint32_t)(csi & 0xffU) << (uint32_t)RDEV_CFG_I2C_BITS) | \
          ((uint32_t)(disPwrCtrl & 1U) << (uint32_t)RDEV_CFG_SLV_BIT))
 
#define CDI_SLV_RDEV_CFG(csi, i2c) \
        ((i2c) | ((uint32_t)(csi) << RDEV_CFG_I2C_BITS) | ((uint32_t)(1U) << RDEV_CFG_CSI_BITS))
 
 
struct DevBlkCDISensorControl;
 
struct DevBlkCDIEmbeddedDataChunk;
 
struct DevBlkCDIEmbeddedDataInfo;
 
struct DevBlkCDISensorAttributes;
 
#if !NV_IS_SAFETY
struct DevBlkCDIModuleConfig;
#endif
 /* Ends Basic CDI Types group */
 
typedef struct {
    void *deviceDriverHandle;
} DevBlkCDIDevice;
 
typedef enum {
    DEVBLK_CDI_I2C_BUS_0 = 0, 
    DEVBLK_CDI_I2C_BUS_1 = 1, 
    DEVBLK_CDI_I2C_BUS_2 = 2, 
    DEVBLK_CDI_I2C_BUS_3 = 3, 
    DEVBLK_CDI_I2C_BUS_4 = 4, 
    DEVBLK_CDI_I2C_BUS_5 = 5, 
    DEVBLK_CDI_I2C_BUS_6 = 6, 
    DEVBLK_CDI_I2C_BUS_7 = 7, 
    DEVBLK_CDI_I2C_BUS_8 = 8, 
    DEVBLK_CDI_I2C_BUS_9 = 9, 
    DEVBLK_CDI_I2C_BUS_10 = 10, 
    DEVBLK_CDI_I2C_BUS_11 = 11, 
    DEVBLK_CDI_I2C_SIMULATOR = 255, 
} DevBlkCDI_I2CPort;
 
#define DEVBLK_CDI_ROOT_DEVICE_MAX_GPIOS (8U)
 
typedef struct {
    uint32_t idxs[DEVBLK_CDI_ROOT_DEVICE_MAX_GPIOS];
    uint32_t count;
} DevBlkCDIGPIOIndices;
 
#define DEVBLK_CDI_GPIO_LEVEL_LOW     (1U)
#define DEVBLK_CDI_GPIO_LEVEL_HIGH    (2U)
 
typedef enum {
    DEVBLK_CDI_GPIO_EVENT_NOTHING = 0,
    DEVBLK_CDI_GPIO_EVENT_INTR,
    DEVBLK_CDI_GPIO_EVENT_ERROR_WAIT_CANCELLED,
    DEVBLK_CDI_GPIO_EVENT_ERROR_CDAC,
    DEVBLK_CDI_GPIO_EVENT_ERROR_BACKEND,
    DEVBLK_CDI_GPIO_EVENT_ERROR_UNKNOWN,
} DevBlkCDIGpioEvent;
 
typedef void DevBlkCDIRootDevice;
 
DevBlkCDIRootDevice *
DevBlkCDIRootDeviceCreate(
    uint32_t portCfg,
    DevBlkCDIGPIOIndices gpios,
    const bool useCDIv2API
);
 
void
DevBlkCDIRootDeviceDestroy(
    DevBlkCDIRootDevice *device
);
 
NvMediaStatus
DevBlkCDIRootDeviceGetGPIOPinLevel(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx,
    uint32_t *level
);
 
NvMediaStatus
DevBlkCDIRootDeviceSetGPIOPinLevel(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx,
    uint32_t level
);
 
NvMediaStatus
DevBlkCDIRootDeviceCheckAndClearIntr(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx
);
 
NvMediaStatus
DevBlkCDIRootDeviceWaitForError(
    DevBlkCDIRootDevice const *device,
    DevBlkCDIGPIOIndices *gpios
);
 
NvMediaStatus
DevBlkCDIRootDeviceGetGpioIntrEvent(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx,
    DevBlkCDIGpioEvent *event_code
);
 
NvMediaStatus
DevBlkCDIRootDeviceAbortWaitForError(
    DevBlkCDIRootDevice const *device
);
 
typedef struct {
    const char *deviceName;
    uint32_t regLength;
    uint32_t dataLength;
 
    NvMediaStatus (* DriverCreate)(
        DevBlkCDIDevice *handle,
        void const* clientContext);
 
    NvMediaStatus (* DriverDestroy)(
        DevBlkCDIDevice *handle);
 
    NvMediaStatus (* SetSensorControls)(
        DevBlkCDIDevice const* handle,
        const struct DevBlkCDISensorControl *sensorControl,
        const size_t sensrCtrlStructSize);
 
    NvMediaStatus (* ParseEmbedDataInfo)(
        DevBlkCDIDevice const* handle,
        const struct DevBlkCDIEmbeddedDataChunk *embeddedTopDataChunk,
        const struct DevBlkCDIEmbeddedDataChunk *embeddedBotDataChunk,
        const size_t dataChunkStructSize,
        struct DevBlkCDIEmbeddedDataInfo *embeddedDataInfo,
        const size_t dataInfoStructSize);
 
    NvMediaStatus (* GetSensorAttributes)(
        DevBlkCDIDevice const* handle,
        struct DevBlkCDISensorAttributes *sensorAttr,
        const size_t sensorAttrStructSize);
 
#if !NV_IS_SAFETY
 
    NvMediaStatus (* GetModuleConfig)(
        DevBlkCDIDevice *handle,
        struct DevBlkCDIModuleConfig *moduleConfig);
 
    NvMediaStatus (* SetSensorCharMode)(
        DevBlkCDIDevice *handle,
        uint8_t expNo);
#endif
 
    NvMediaStatus (* ReadRegister)(
        DevBlkCDIDevice const* handle,
        uint32_t deviceIndex,
        uint32_t registerNum,
        uint32_t dataLength,
        uint8_t *dataBuff);
 
    NvMediaStatus (* WriteRegister)(
        DevBlkCDIDevice const* handle,
        uint32_t deviceIndex,
        uint32_t registerNum,
        uint32_t dataLength,
        uint8_t const* dataBuff);
 
} DevBlkCDIDeviceDriver;
 
typedef struct {
    void *clientContext;
} DevBlkCDIAdvancedConfig;
 
DevBlkCDIDevice *
DevBlkCDIDeviceCreate(
    DevBlkCDIRootDevice *rootDevice,
    uint32_t *deviceAddressList,
    uint32_t numDevices,
    DevBlkCDIDeviceDriver *deviceDriverParam,
    DevBlkCDIAdvancedConfig const *advancedConfig,
    uint8_t linkIndex,
    NvSiplBool isDeserializer,
    NvSiplBool useNativeI2CAddress,
    NvSiplBool useCDIv2API
);
 
void
DevBlkCDIDeviceDestroy(
    DevBlkCDIDevice *device
);
 
NvMediaStatus
DevBlkCDIDeviceRead(
    DevBlkCDIDevice const *device,
    uint32_t deviceIndex,
    uint32_t regLength,
    uint8_t *regData,
    uint32_t dataLength,
    uint8_t *data
);
 
NvMediaStatus
DevBlkCDIDeviceWrite(
    DevBlkCDIDevice const *device,
    uint32_t deviceIndex,
    uint32_t dataLength,
    const uint8_t *data
);
 
NvMediaStatus
DevBlkCDIGetSensorAttributes(
    DevBlkCDIDevice *device,
    DevBlkCDISensorAttributes *sensorAttr,
    const size_t sensorAttrStructSize);
 
typedef struct DevBlkCDISensorControl {
    uint8_t                 numSensorContexts;
 
    DevBlkCDIExposure       exposureControl[DEVBLK_CDI_MAX_SENSOR_CONTEXTS];
 
    DevBlkCDIWhiteBalance   wbControl[DEVBLK_CDI_MAX_SENSOR_CONTEXTS];
 
    DevBlkCDIFrameReport    frameReportControl;
 
} DevBlkCDISensorControl;
 
NvMediaStatus
DevBlkCDISetSensorControls(
    DevBlkCDIDevice *device,
    const DevBlkCDISensorControl *sensorControl,
    const size_t sensrCtrlStructSize
);
 
NvMediaStatus
DevBlkCDIParseEmbedDataInfo(
    DevBlkCDIDevice *device,
    const DevBlkCDIEmbeddedDataChunk *embeddedTopDataChunk,
    const DevBlkCDIEmbeddedDataChunk *embeddedBotDataChunk,
    const size_t embeddedDataChunkStructSize,
    DevBlkCDIEmbeddedDataInfo *embeddedDataInfo,
    const size_t dataInfoStructSize);
 
NvMediaStatus
DevBlkCDISetCameraPower(
    DevBlkCDIRootDevice const *device,
    uint8_t linkIndex,
    NvMediaBool enable);
 
NvMediaStatus
DevBlkCDIEnableErrorReport(
    DevBlkCDIRootDevice const *device);
 
NvMediaStatus
DevBlkCDIGetDesPowerControlMethod(
    DevBlkCDIDevice *device,
    uint8_t *desPwrMethod);
 
NvMediaStatus
DevBlkCDIGetCamPowerControlMethod(
    DevBlkCDIDevice *device,
    uint8_t *camPwrMethod);
 
#if !NV_IS_SAFETY
 
typedef enum {
    DEVBLK_CDI_PWR_AGGREGATOR,
    DEVBLK_CDI_PWR_LINK_0,
    DEVBLK_CDI_PWR_LINK_1,
    DEVBLK_CDI_PWR_LINK_2,
    DEVBLK_CDI_PWR_LINK_3,
} DevBlkCDIPowerItems;
 
typedef struct DevBlkCDIModuleConfig {
    char cameraModuleCfgName[128];
    const char *cameraModuleConfigPass1;
    const char *cameraModuleConfigPass2;
} DevBlkCDIModuleConfig;
 
typedef enum {
    DEVBLK_CDI_EXPOSURE_MODE_LONG,
    DEVBLK_CDI_EXPOSURE_MODE_SHORT,
    DEVBLK_CDI_EXPOSURE_MODE_VERY_SHORT,
    DEVBLK_CDI_EXPOSURE_MODE_MAX
} DevBlkCDIExposureMode;
 
typedef struct DevBlkCDIExposureControl {
    struct {
        float_t value;
        NvSiplBool valid;
    } exposureTime[DEVBLK_CDI_EXPOSURE_MODE_MAX];
    struct {
        float_t value;
        NvSiplBool valid;
    } sensorGain[DEVBLK_CDI_EXPOSURE_MODE_MAX];
    uint8_t sensorFrameId;
} DevBlkCDIExposureControl;
 
typedef struct DevBlkCDIWBGainControl {
    struct {
        float_t value[4];
        NvSiplBool valid;
    } wbGain[DEVBLK_CDI_EXPOSURE_MODE_MAX];
} DevBlkCDIWBGainControl;
 
typedef struct {
    uint32_t baseRegAddress;
    uint32_t size;
    uint32_t bufferSize;
    uint8_t *data;
} DevBlkCDIEmbeddedDataBuffer;
 
typedef struct DevBlkCDIEmbeddedData {
    DevBlkCDIEmbeddedDataBuffer top;
    DevBlkCDIEmbeddedDataBuffer bottom;
    DevBlkCDIExposureControl exposureControl;
    DevBlkCDIWBGainControl wbControl;
    uint32_t frameSequenceNumber;
} DevBlkCDIEmbeddedData;
 
typedef enum {
    DEVBLK_CDI_SENSOR_ATTR_FUSE_ID,
    DEVBLK_CDI_SENSOR_ATTR_GAIN_MIN,
    DEVBLK_CDI_SENSOR_ATTR_GAIN_MAX,
    DEVBLK_CDI_SENSOR_ATTR_ET_MIN,
    DEVBLK_CDI_SENSOR_ATTR_ET_MAX,
    DEVBLK_CDI_SENSOR_ATTR_ET_FINE,
    DEVBLK_CDI_SENSOR_ATTR_ET_STEP,
    DEVBLK_CDI_SENSOR_ATTR_HDR_MAX,
    DEVBLK_CDI_SENSOR_ATTR_GAIN_FACTOR,
    DEVBLK_CDI_SENSOR_ATTR_QE_PIXEL_RATIO,
    DEVBLK_CDI_SENSOR_ATTR_FRAME_RATE,
    DEVBLK_CDI_SENSOR_ATTR_NUM_EXPOSURES,
} DevBlkCDISensorAttrType;
 
NvMediaStatus
DevBlkCDISetSensorCharMode(
    DevBlkCDIDevice *device,
    uint8_t expNo);
 
NvMediaStatus
DevBlkCDIGetModuleConfig(
    DevBlkCDIDevice *device,
    DevBlkCDIModuleConfig *moduleConfig);
 
#endif /* #if !NV_IS_SAFETY */
 
#ifdef __cplusplus
}     /* extern "C" */
#endif
 
#endif /* DEVBLK_CDI_H */