NvSIPLDeviceBlockInfo.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-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 NVSIPLDEVICEBLOCKINFO_HPP
#define NVSIPLDEVICEBLOCKINFO_HPP
 
#include "NvSIPLCapStructs.h"
 
#include <string>
#include <memory>
#include <vector>
#include <cmath>
 
namespace nvsipl
{
#if !NV_IS_SAFETY
static constexpr uint32_t MAX_DEVICEBLOCKS_PER_PLATFORM {6U};
#else
static constexpr uint32_t MAX_DEVICEBLOCKS_PER_PLATFORM {4U};
#endif
 
static constexpr uint32_t MAX_CAMERAMODULES_PER_BLOCK {4U};
 
static constexpr uint32_t MAX_CAMERAMODULES_PER_PLATFORM {MAX_DEVICEBLOCKS_PER_PLATFORM * MAX_CAMERAMODULES_PER_BLOCK};
 
static constexpr uint32_t MAX_SENSORS_PER_PLATFORM {MAX_CAMERAMODULES_PER_PLATFORM};
 
static constexpr std::uint32_t MAX_CSI_LANE_CONFIGURATION {2U};
 
static constexpr std::uint32_t X2_CSI_LANE_CONFIGURATION {0U};
 
static constexpr std::uint32_t X4_CSI_LANE_CONFIGURATION {1U};
 
struct IntrGpioInfo
{
    uint32_t idx;
    bool enableGetStatus;
    uint32_t timeout_ms;
};
 
struct SensorInfo
{
    struct Resolution
    {
        uint32_t width {0U};
 
        uint32_t height {0U};
    };
 
    struct VirtualChannelInfo
    {
        uint32_t cfa {0U};
        uint32_t embeddedTopLines {UINT32_MAX};
        uint32_t embeddedBottomLines {UINT32_MAX};
        NvSiplCapInputFormatType inputFormat {NVSIPL_CAP_INPUT_FORMAT_TYPE_RAW12};
        Resolution resolution;
        float_t fps {0.0F};
        bool isEmbeddedDataTypeEnabled {false};
    };
 
    uint32_t id = UINT32_MAX;
    std::string name = "";
#if !NV_IS_SAFETY
 
    std::string description = "";
#endif // !NV_IS_SAFETY
 
    uint8_t i2cAddress {static_cast<uint8_t>UINT8_MAX};
    VirtualChannelInfo vcInfo;
    bool isTriggerModeEnabled {false};
    std::vector<IntrGpioInfo> errGpios {};
    bool useCDIv2API {false};
#ifdef NVMEDIA_QNX
 
    bool isAuthEnabled {true};
#else
    // Linux doesn't support authentication
    bool isAuthEnabled {false};
#endif // NVMEDIA_QNX
#if !NV_IS_SAFETY
 
    bool isTPGEnabled {false};
    uint32_t patternMode {0U};
#endif // !NV_IS_SAFETY
};
 
struct EEPROMInfo
{
    std::string name = "";
#if !NV_IS_SAFETY
 
    std::string description = "";
#endif 
 
    uint8_t i2cAddress {static_cast<uint8_t>UINT8_MAX};
 
    bool useCDIv2API {false};
};
 
struct SerdesGPIOPinMap {
    uint8_t sourceGpio;
    uint8_t destGpio;
};
 
struct SerInfo
{
    std::string name = "";
#if !NV_IS_SAFETY
 
    std::string description = "";
#endif // !NV_IS_SAFETY
 
    uint8_t i2cAddress {static_cast<uint8_t>UINT8_MAX};
#if !NV_IS_SAFETY
 
    bool longCable {false};
#endif // !NV_IS_SAFETY
 
    std::vector<IntrGpioInfo> errGpios {};
    bool useCDIv2API {false};
    std::vector<SerdesGPIOPinMap> serdesGPIOPinMappings {};
};
 
class CryptoKeyInfo {
    std::string keyPurpose;
    std::string keyName;
    uint32_t cryptoChanID;
public:
    CryptoKeyInfo(std::string const &purpose,
                  std::string const &name,
                  uint32_t const chanID):
                      keyPurpose(purpose), keyName(name), cryptoChanID(chanID) { }
 
    std::string const &name() const noexcept { return keyName; }
    std::string const &purpose() const noexcept { return keyPurpose; }
    uint32_t chanID() const noexcept { return cryptoChanID; }
};
 
struct CameraModuleInfo
{
    std::string name = "";
#if !NV_IS_SAFETY
 
    std::string description = "";
#endif // !NV_IS_SAFETY
 
    uint32_t linkIndex {UINT32_MAX};
#if !(NV_IS_SAFETY) || (SAFETY_DBG_OV)
 
    bool isSimulatorModeEnabled {false};
#endif // !(NV_IS_SAFETY) || (SAFETY_DBG_OV)
 
    SerInfo serInfo;
    bool isEEPROMSupported {false};
    EEPROMInfo eepromInfo;
    SensorInfo sensorInfo;
    std::vector<CryptoKeyInfo> cryptoKeysList {};
};
 
struct DeserInfo
{
    std::string name = "";
#if !NV_IS_SAFETY
 
    std::string description = "";
#endif // !NV_IS_SAFETY
 
    uint8_t i2cAddress {static_cast<uint8_t>UINT8_MAX};
    std::vector<IntrGpioInfo> errGpios {};
    bool useCDIv2API {false};
    bool resetAll {false};
};
 
struct DeviceBlockInfo
{
    NvSiplCapInterfaceType csiPort {NVSIPL_CAP_CSI_INTERFACE_TYPE_CSI_A};
    NvSiplCapCsiPhyMode phyMode = NVSIPL_CAP_CSI_DPHY_MODE;
    uint32_t i2cDevice {UINT32_MAX};
    DeserInfo deserInfo;
    uint32_t numCameraModules {0U};
    CameraModuleInfo cameraModuleInfoList[MAX_CAMERAMODULES_PER_BLOCK];
    std::uint32_t desI2CPort {UINT32_MAX};
    std::uint32_t desTxPort {UINT32_MAX};
    std::uint32_t pwrPort = UINT32_MAX;
    std::uint32_t dphyRate[MAX_CSI_LANE_CONFIGURATION] = {0U};
    std::uint32_t cphyRate[MAX_CSI_LANE_CONFIGURATION] = {0U};
    bool isPassiveModeEnabled {false};
    bool isGroupInitProg {false};
    std::vector<uint32_t> gpios {};
#if !NV_IS_SAFETY
 
    bool isPwrCtrlDisabled {false};
    bool longCables[MAX_CAMERAMODULES_PER_BLOCK] = {false};
#endif // !NV_IS_SAFETY
 
    bool resetAll;
    std::string bootAcceleratorTag = "";
    bool bootAcceleratorUseStaggeredStart = {false};
};
 
} // namespace nvsipl
 
#endif //NVSIPLDEVICEBLOCKINFO_HPP