devblk_cdi.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2014-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly 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           8U
 
#define RDEV_CFG_CSI_BITS           (RDEV_CFG_I2C_BITS + 8U)
 
#define RDEV_CFG_SLV_BIT            (RDEV_CFG_CSI_BITS + 1U)
 
#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 *deviceHandle;
    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_BUS_12 = 12, 
    DEVBLK_CDI_I2C_BUS_13 = 13, 
    DEVBLK_CDI_I2C_BUS_14 = 14, 
    DEVBLK_CDI_I2C_BUS_15 = 15, 
    DEVBLK_CDI_I2C_BUS_16 = 16, 
    DEVBLK_CDI_I2C_SIMULATOR = 255, 
} DevBlkCDI_I2CPort;
 
#define DEVBLK_CDI_ROOT_DEVICE_MAX_GPIOS (16U)
 
#define MAX_POWER_LINKS_PER_BLOCK (4U)
 
typedef struct {
    uint8_t method;
    uint8_t i2cAddr;
    uint8_t links[MAX_POWER_LINKS_PER_BLOCK];
} DevBlkCDIPowerControlInfo;
 
typedef struct {
    uint8_t *imageData;
    uint64_t imageDataDMA;
    uint32_t pitch;
    uint32_t height;
    uint8_t const *embDataTop;
    uint32_t embSizeTop;
    uint8_t const *embDataBottom;
    uint32_t embSizeBottom;
} DevBlkImageDesc;
 
#define DEVBLK_CDI_GPIO_LEVEL_LOW     (1U)
#define DEVBLK_CDI_GPIO_LEVEL_HIGH    (2U)
 
typedef enum {
    DEVBLK_CDI_GPIO_EVENT_INTR = 0,
    DEVBLK_CDI_GPIO_EVENT_INTR_TIMEOUT,
    DEVBLK_CDI_GPIO_EVENT_ERROR_CAMGPIO,
    DEVBLK_CDI_GPIO_EVENT_ERROR_BACKEND,
    DEVBLK_CDI_GPIO_EVENT_ERROR_UNKNOWN,
} DevBlkCDIGpioEvent;
 
typedef struct {
    struct {
        uint32_t idx;
        uint32_t timeout_ms;
        DevBlkCDIGpioEvent evt;
    } pins[DEVBLK_CDI_ROOT_DEVICE_MAX_GPIOS];
    uint32_t count;
} DevBlkCDIGPIOIndices;
 
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
DevBlkCDIRootDeviceCheckGPIOPinLevel(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx,
    uint32_t expected_level
);
 
NvMediaStatus
DevBlkCDIRootDevicePollGPIOPinLevel(
    DevBlkCDIDevice const *device,
    uint32_t gpio_idx,
    uint32_t expected_level,
    uint32_t poll_count,
    uint32_t poll_delay
);
 
NvMediaStatus
DevBlkCDIRootDeviceSetGPIOPinLevel(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx,
    uint32_t level
);
 
NvMediaStatus
DevBlkCDIRootDeviceCheckIntrPin(
    DevBlkCDIRootDevice const *device,
    uint32_t gpio_idx
);
 
NvMediaStatus
DevBlkCDIRootDeviceIsPulseErrorSupported(void);
 
 
NvMediaStatus
DevBlkCDIRootDeviceWaitForPulseError(
    DevBlkCDIRootDevice const *device);
 
NvMediaStatus
DevBlkCDIRootDeviceWaitForError(
    DevBlkCDIRootDevice const *device,
    DevBlkCDIGPIOIndices *gpios
);
 
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 (* ParseTopEmbDataInfo)(
        DevBlkCDIDevice const* handle,
        const struct DevBlkCDIEmbeddedDataChunk *topEmbDataChunk,
        const size_t topChunkStructSize,
        struct DevBlkCDIEmbeddedDataInfo *embeddedDataInfo,
        const size_t dataInfoStructSize);
 
    NvMediaStatus (* ParseBotEmbDataInfo)(
        DevBlkCDIDevice const* handle,
        const struct DevBlkCDIEmbeddedDataChunk *botEmbDataChunk,
        const size_t botChunkStructSize,
        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);
 
 
    NvMediaStatus (* AuthenticateImage)(
        DevBlkCDIDevice const * const handle,
        DevBlkImageDesc const * const imageDesc);
 
} DevBlkCDIDeviceDriver;
 
typedef struct {
    void *clientContext;
} DevBlkCDIAdvancedConfig;
 
DevBlkCDIDevice *
DevBlkCDIDeviceCreate(
    DevBlkCDIRootDevice *rootDevice,
    uint32_t *deviceAddressList,
    uint32_t numDevices,
    DevBlkCDIDeviceDriver *deviceDriverParam,
    DevBlkCDIAdvancedConfig const *advancedConfig,
    uint8_t linkIndex,
    NvMediaBool isDeserializer,
    NvMediaBool useNativeI2CAddress,
    NvMediaBool useCDIv2API
);
 
void
DevBlkCDIDeviceDestroy(
    DevBlkCDIDevice *device
);
 
#if !(NV_IS_SAFETY)
 
NvMediaStatus
DevBlkCDIDeviceRead(
    DevBlkCDIDevice const *device,
    uint32_t deviceIndex,
    uint32_t regLength,
    uint8_t *regData,
    uint32_t dataLength,
    uint8_t *data
);
#endif
 
#if !(NV_IS_SAFETY)
 
NvMediaStatus
DevBlkCDIDeviceWrite(
    DevBlkCDIDevice const *device,
    uint32_t deviceIndex,
    uint32_t dataLength,
    const uint8_t *data
);
#endif
 
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;
 
    DevBlkCDIIllumination   illuminationControl;
} DevBlkCDISensorControl;
 
NvMediaStatus
DevBlkCDISetSensorControls(
    DevBlkCDIDevice *device,
    const DevBlkCDISensorControl *sensorControl,
    const size_t sensrCtrlStructSize
);
 
NvMediaStatus
DevBlkCDIParseTopEmbDataInfo(
    DevBlkCDIDevice *device,
    const DevBlkCDIEmbeddedDataChunk *embeddedTopDataChunk,
    const size_t embeddedDataChunkStructSize,
    DevBlkCDIEmbeddedDataInfo *embeddedDataInfo,
    const size_t dataInfoStructSize);
 
NvMediaStatus
DevBlkCDIParseBotEmbDataInfo(
    DevBlkCDIDevice *device,
    const DevBlkCDIEmbeddedDataChunk *embeddedBotDataChunk,
    const size_t embeddedDataChunkStructSize,
    DevBlkCDIEmbeddedDataInfo *embeddedDataInfo,
    const size_t dataInfoStructSize);
 
NvMediaStatus
DevBlkCDISetDeserPower(
    DevBlkCDIDevice *device,
    NvMediaBool enable);
 
NvMediaStatus
DevBlkCDIEnableErrorReport(
    DevBlkCDIRootDevice const *device);
 
NvMediaStatus
DevBlkCDIGetDesPowerControlInfo(
    DevBlkCDIDevice *device,
    DevBlkCDIPowerControlInfo *desPwrControlInfo);
 
NvMediaStatus
DevBlkCDIGetCamPowerControlInfo(
    DevBlkCDIDevice *device,
    DevBlkCDIPowerControlInfo *camPwrControlInfo);
 
NvMediaStatus
DevBlkCDIReserveI2CAddr(
    DevBlkCDIDevice *device,
    uint8_t address,
    bool useNativeI2C,
    uint32_t *reservedI2CAddr);
 
NvMediaStatus
DevBlkCDISetFsyncMux(
    DevBlkCDIDevice *device,
    uint32_t fsyncMuxSel,
    uint32_t camGrpIdx);
 
NvMediaStatus
DevBlkCDIAuthenticateImage(
        DevBlkCDIDevice const * const device,
        DevBlkImageDesc const * const imageDesc);
 
#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;
 
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 */