node-gpuinfo 1.0.0

package/src/includes/adlx/IGPUTuning1.h

@@ -0,0 +1,197 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_IGPUTUNING1_H
+#define ADLX_IGPUTUNING1_H
+#pragma once
+
+#include "ADLXStructures.h"
+#include "IGPUTuning.h"
+
+//-------------------------------------------------------------------------------------------------
+//IGPUTuning1.h - Interfaces for ADLX GPU Tuning functionality
+
+#pragma region IADLXGPUTuningServices1
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXGPU;
+    class ADLX_NO_VTABLE IADLXSmartAccessMemory;
+    class ADLX_NO_VTABLE IADLXGPUTuningServices1 : public IADLXGPUTuningServices
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXGPUTuningServices1")
+
+        /**
+        *@page DOX_IADLXGPUTuningServices1_GetSmartAccessMemory GetSmartAccessMemory
+        *@ENG_START_DOX @brief Gets the reference counted AMD SmartAccess Memory interface for a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetSmartAccessMemory (@ref DOX_IADLXGPU* pGPU, @ref DOX_IADLXSmartAccessMemory** ppSmartAccessMemory)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[in] ,pGPU,@ref DOX_IADLXGPU* ,@ENG_START_DOX The pointer to the GPU interface. @ENG_END_DOX}
+        *@paramrow{2.,[out],ppSmartAccessMemory,@ref DOX_IADLXSmartAccessMemory**,@ENG_START_DOX The address of a pointer to the returned interface. If the interface is not successfully returned\, the method sets the dereferenced address __*ppSmartAccessMemory__ to __nullptr__. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the interface is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the interface is not successfully returned, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *@detaileddesc
+        *@ENG_START_DOX @details The returned interface must be discarded with @ref DOX_IADLXInterface_Release when its no longer needed. @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        *In C++, when using ADLX interfaces as smart pointers, there is no need to call @ref DOX_IADLXInterface_Release because smart pointers call it in their internal implementation. @ENG_END_DOX
+        *
+        *@copydoc IADLXGPUTuningServices1_REQ_TABLE
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetSmartAccessMemory(IADLXGPU* pGPU, IADLXSmartAccessMemory** ppSmartAccessMemory) = 0;
+    }; //IADLXGPUTuningServices1
+    typedef IADLXInterfacePtr_T<IADLXGPUTuningServices1> IADLXGPUTuningServices1Ptr;
+} // namespace adlx
+#else // __cplusplus
+ADLX_DECLARE_IID(IADLXGPUTuningServices1, L"IADLXGPUTuningServices1")
+typedef struct IADLXSmartAccessMemory IADLXSmartAccessMemory;
+typedef struct IADLXGPUTuningServices1 IADLXGPUTuningServices1;
+
+typedef struct IADLXGPUTuningServices1Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXGPUTuningServices1* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXGPUTuningServices1* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXGPUTuningServices1* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXGPUTuningServices
+    ADLX_RESULT(ADLX_STD_CALL* GetGPUTuningChangedHandling)(IADLXGPUTuningServices1* pThis, IADLXGPUTuningChangedHandling** ppGPUTuningChangedHandling);
+    ADLX_RESULT(ADLX_STD_CALL* IsAtFactory)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* isFactory);
+    ADLX_RESULT(ADLX_STD_CALL* ResetToFactory)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU);
+
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedAutoTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedPresetTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedManualGFXTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedManualVRAMTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedManualFanTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+    ADLX_RESULT(ADLX_STD_CALL* IsSupportedManualPowerTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, adlx_bool* supported);
+
+    ADLX_RESULT(ADLX_STD_CALL* GetAutoTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppAutoTuning);
+    ADLX_RESULT(ADLX_STD_CALL* GetPresetTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppPresetTuning);
+    ADLX_RESULT(ADLX_STD_CALL* GetManualGFXTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppManualGFXTuning);
+    ADLX_RESULT(ADLX_STD_CALL* GetManualVRAMTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppManualVRAMTuning);
+    ADLX_RESULT(ADLX_STD_CALL* GetManualFanTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppManualFanTuning);
+    ADLX_RESULT(ADLX_STD_CALL* GetManualPowerTuning)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXInterface** ppManualPowerTuning);
+
+    //IADLXGPUTuningServices1
+    ADLX_RESULT(ADLX_STD_CALL* GetSmartAccessMemory)(IADLXGPUTuningServices1* pThis, IADLXGPU* pGPU, IADLXSmartAccessMemory** ppSmartAccessMemory);
+}IADLXGPUTuningServices1Vtbl;
+
+struct IADLXGPUTuningServices1 { const IADLXGPUTuningServices1Vtbl* pVtbl; };
+#endif // __cplusplus
+#pragma endregion IADLXGPUTuningServices1
+
+#pragma region IADLXGPUTuningChangedEvent1
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXGPUTuningChangedEvent1 : public IADLXGPUTuningChangedEvent
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXGPUTuningChangedEvent1")
+
+        /**
+        *@page DOX_IADLXGPUTuningChangedEvent1_IsSmartAccessMemoryChanged IsSmartAccessMemoryChanged
+        *@ENG_START_DOX @brief Checks for changes to the AMD SmartAccess Memory settings. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * adlx_bool    IsSmartAccessMemoryChanged ()
+        *@codeEnd
+        *
+        *@params
+        *N/A
+        *
+        *@retvalues
+        *@ENG_START_DOX  If AMD SmartAccess Memory settings are changed, __true__ is returned.<br>
+        * If AMD SmartAccess Memory settings are not changed, __false__ is returned.<br> @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        * __Note:__ To obtain the GPU, use @ref DOX_IADLXGPUTuningChangedEvent_GetGPU.
+        * @ENG_END_DOX
+        *
+        *@copydoc IADLXGPUTuningChangedEvent1_REQ_TABLE
+        *
+        */
+        virtual adlx_bool ADLX_STD_CALL IsSmartAccessMemoryChanged() = 0;
+
+        /**
+        *@page DOX_IADLXGPUTuningChangedEvent1_GetSmartAccessMemoryStatus GetSmartAccessMemoryStatus
+        *@ENG_START_DOX @brief Gets the current AMD SmartAccess Memory status. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetSmartAccessMemoryStatus (adlx_bool* pEnabled, adlx_bool* pCompleted)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[out] ,pEnabled,adlx_bool* ,@ENG_START_DOX The pointer to a variable where the current state of AMD SmartAccess Memory is returned. The variable is __true__ if AMD SmartAccess Memory is enabled. The variable is __false__ if AMD SmartAccess Memory is disabled. @ENG_END_DOX}
+        *@paramrow{2.,[out] ,pEnabled,adlx_bool* ,@ENG_START_DOX The pointer to a variable where the complete state of AMD SmartAccess Memory is returned. The variable is __true__ if AMD SmartAccess Memory is completed. The variable is __false__ if AMD SmartAccess Memory is not completed. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the interface is successfully returned, __ADLX_OK__ is returned.<br>
+        * If the interface is not successfully returned, an error code is returned.<br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes.<br> @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        * __Note:__ Use @ref DOX_IADLXGPUTuningChangedEvent_GetGPU to obtain the GPU.
+        * @ENG_END_DOX
+        *
+        *@copydoc IADLXGPUTuningChangedEvent1_REQ_TABLE
+        * 
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetSmartAccessMemoryStatus(adlx_bool* pEnabled, adlx_bool* pCompleted) = 0;
+    };
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXGPUTuningChangedEvent1> IADLXGPUTuningChangedEvent1Ptr;
+} //namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXGPUTuningChangedEvent1, L"IADLXGPUTuningChangedEvent1")
+
+typedef struct IADLXGPUTuningChangedEvent1 IADLXGPUTuningChangedEvent1;
+
+typedef struct IADLXGPUTuningChangedEvent1Vtbl
+{
+    // IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXGPUTuningChangedEvent1* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXGPUTuningChangedEvent1* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    // IADLXChangedEvent
+    ADLX_SYNC_ORIGIN(ADLX_STD_CALL* GetOrigin)(IADLXGPUTuningChangedEvent1* pThis);
+
+    // IADLXGPUTuningChangedEvent
+    ADLX_RESULT(ADLX_STD_CALL* GetGPU)(IADLXGPUTuningChangedEvent1* pThis, IADLXGPU** ppGPU);
+    adlx_bool(ADLX_STD_CALL* IsAutomaticTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsPresetTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsManualGPUCLKTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsManualVRAMTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsManualFanTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsManualPowerTuningChanged)(IADLXGPUTuningChangedEvent1* pThis);
+
+    // IADLXGPUTuningChangedEvent1
+    adlx_bool(ADLX_STD_CALL* IsSmartAccessMemoryChanged)(IADLXGPUTuningChangedEvent1* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* GetSmartAccessMemoryStatus)(IADLXGPUTuningChangedEvent1* pThis, adlx_bool* pEnabled, adlx_bool* pCompleted);
+} IADLXGPUTuningChangedEvent1Vtbl;
+
+struct IADLXGPUTuningChangedEvent1 { const IADLXGPUTuningChangedEvent1Vtbl* pVtbl; };
+#endif //__cplusplus
+#pragma endregion IADLXGPUTuningChangedEvent1
+
+#endif // ADLX_IGPUTUNING1_H

package/src/includes/adlx/II2C.h

@@ -0,0 +1,198 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_II2C_H
+#define ADLX_II2C_H
+#pragma once
+
+#include "ADLXDefines.h"
+
+//-------------------------------------------------------------------------------------------------
+//II2C.h - Interfaces for ADLX GPU I2C functionality
+
+//I2C setting interface
+#pragma region IADLXI2C
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXI2C : public IADLXInterface
+    {
+    public:
+        ADLX_DECLARE_IID (L"IADLXI2C")
+
+        /**
+        *@page DOX_IADLXI2C_Version Version
+        *@ENG_START_DOX @brief Retrieves the major and minor software version of I2C interface on a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    Version (adlx_int* major, adlx_int* minor)
+        *@codeEnd
+        *
+        *@params
+        * @paramrow{1.,[out],major,adlx_int*,@ENG_START_DOX A pointer to a variable where the I2C major version is returned. @ENG_END_DOX}
+        * @paramrow{2.,[out],minor,adlx_int*,@ENG_START_DOX A pointer to a variable where the I2C minor version is returned. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the I2C major version and the I2C minor version are successfully returned, __ADLX_OK__ is returned. <br>
+        * If the I2C major version and the I2C minor version are not successfully returned, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *
+        *
+        *@copydoc IADLXI2C_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT         ADLX_STD_CALL Version (adlx_int* major, adlx_int* minor) = 0;
+
+        /**
+        *@page DOX_IADLXI2C_IsSupported IsSupported
+        *@ENG_START_DOX @brief Checks if the OEM device data can be read and written through the I2C bus on a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    IsSupported (@ref ADLX_I2C_LINE line, adlx_int address, adlx_bool* isSupported)
+        *@codeEnd
+        *
+        *@params
+        * @paramrow{1.,[in],line,@ref ADLX_I2C_LINE,@ENG_START_DOX The I2C line. @ENG_END_DOX}
+        * @paramrow{2.,[in],address,adlx_int,@ENG_START_DOX The 7-bit I2C slave device address which is shifted one bit to the left. @ENG_END_DOX}
+        * @paramrow{2.,[out],isSupported,adlx_bool*,@ENG_START_DOX A pointer to a variable where the status of the I2C bus read and write is returned. The variable is __true__ if the OEM device data can be read and written through the I2C bus. The variable is __false__ if the OEM device data cannot be read and written through the I2C bus. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the status of the I2C bus read and write is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the status of the I2C bus read and write is not successfully returned, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *
+        *
+        *@copydoc IADLXI2C_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT         ADLX_STD_CALL IsSupported (ADLX_I2C_LINE line, adlx_int address, adlx_bool* isSupported) = 0;
+
+        /**
+        *@page DOX_IADLXI2C_Read Read
+        *@ENG_START_DOX @brief Reads the OEM device data through the I2C bus of a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    Read (@ref ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data)
+        *@codeEnd
+        *
+        *@params
+        * @paramrow{1.,[in],line,@ref ADLX_I2C_LINE,@ENG_START_DOX The I2C line. @ENG_END_DOX}
+        * @paramrow{2.,[in],speed,adlx_int,@ENG_START_DOX The I2C clock speed (in KHz). @ENG_END_DOX}
+        * @paramrow{3.,[in],address,adlx_int,@ENG_START_DOX The 7-bit I2C slave device address which is shifted one bit to the left. @ENG_END_DOX}
+        * @paramrow{4.,[in],offset,adlx_int,@ENG_START_DOX The offset of the data from the address. @ENG_END_DOX}
+        * @paramrow{5.,[in],dataSize,adlx_int,@ENG_START_DOX The size (in bytes) of the buffer for the OEM device data. @ENG_END_DOX}
+        * @paramrow{6.,[in],data,adlx_byte*,@ENG_START_DOX The address to the buffer with the new OEM data. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the OEM device data is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the OEM device data is not successfully returned, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *@detaileddesc
+        *@ENG_START_DOX @details The application is responsible to allocate a buffer sufficiently large to hold the requested OEM device data. @ENG_END_DOX
+        *
+        *
+        *@copydoc IADLXI2C_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT         ADLX_STD_CALL Read (ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data) = 0;
+
+        /**
+        *@page DOX_IADLXI2C_RepeatedStartRead RepeatedStartRead
+        *@ENG_START_DOX @brief Repeat start reads the OEM device data through the I2C bus of a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    RepeatedStartRead (@ref ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data)
+        *@codeEnd
+        *
+        *@params
+        * @paramrow{1.,[in],line,@ref ADLX_I2C_LINE,@ENG_START_DOX The I2C line. @ENG_END_DOX}
+        * @paramrow{2.,[in],speed,adlx_int,@ENG_START_DOX The I2C clock speed (in KHz). @ENG_END_DOX}
+        * @paramrow{3.,[in],address,adlx_int,@ENG_START_DOX The 7-bit I2C slave device address which is shifted one bit to the left. @ENG_END_DOX}
+        * @paramrow{4.,[in],offset,adlx_int,@ENG_START_DOX The offset of the data from the address. @ENG_END_DOX}
+        * @paramrow{5.,[in],dataSize,adlx_int,@ENG_START_DOX The size (in bytes) of the buffer for the OEM device data. @ENG_END_DOX}
+        * @paramrow{6.,[in],data,adlx_byte*,@ENG_START_DOX The address to the buffer with the new OEM data. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the OEM device data is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the OEM device data is not successfully returned, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *@detaileddesc
+        *@ENG_START_DOX @details The application is responsible to allocate a buffer sufficiently large to hold the requested OEM device data. @ENG_END_DOX
+        *
+        *
+        *@copydoc IADLXI2C_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT         ADLX_STD_CALL RepeatedStartRead (ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data) = 0;
+
+        /**
+        *@page DOX_IADLXI2C_Write Write
+        *@ENG_START_DOX @brief Writes the OEM device data through the I2C bus of a GPU. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    Write (@ref ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data)
+        *@codeEnd
+        *
+        *@params
+        * @paramrow{1.,[in],line,@ref ADLX_I2C_LINE,@ENG_START_DOX The I2C line. @ENG_END_DOX}
+        * @paramrow{2.,[in],speed,adlx_int,@ENG_START_DOX The I2C clock speed (in KHz). @ENG_END_DOX}
+        * @paramrow{3.,[in],address,adlx_int,@ENG_START_DOX The 7-bit I2C slave device address which is shifted one bit to the left. @ENG_END_DOX}
+        * @paramrow{4.,[in],offset,adlx_int,@ENG_START_DOX The offset of the data from the address. @ENG_END_DOX}
+        * @paramrow{5.,[in],dataSize,adlx_int,@ENG_START_DOX The size (in bytes) of the buffer for the OEM device data.  @ENG_END_DOX}
+        * @paramrow{6.,[in],data,adlx_byte*,@ENG_START_DOX . The address to the buffer with the new OEM data. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX  If the OEM device data is successfully written, __ADLX_OK__ is returned. <br>
+        * If the OEM device data is not successfully written, an error code is returned. <br>
+        * Refer to @ref ADLX_RESULT for success codes and error codes. @ENG_END_DOX
+        *
+        *@detaileddesc
+        *@ENG_START_DOX @details The application is responsible to allocate a buffer sufficiently large to hold the requested OEM device data. @ENG_END_DOX
+        *
+        *
+        *@copydoc IADLXI2C_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT         ADLX_STD_CALL Write (ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data) = 0;
+
+    };  //IADLXI2C
+     //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXI2C> IADLXI2CPtr;
+} //namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID (IADLXI2C, L"IADLXI2C")
+
+typedef struct IADLXI2C IADLXI2C;
+
+typedef struct IADLXI2CVtbl
+{
+    //IADLXInterface
+    adlx_long (ADLX_STD_CALL *Acquire)(IADLXI2C* pThis);
+    adlx_long (ADLX_STD_CALL *Release)(IADLXI2C* pThis);
+    ADLX_RESULT (ADLX_STD_CALL *QueryInterface)(IADLXI2C* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXI2C
+    ADLX_RESULT(ADLX_STD_CALL *Version)(IADLXI2C* pThis, adlx_int* major, adlx_int* minor);
+    ADLX_RESULT(ADLX_STD_CALL *IsSupported)(IADLXI2C* pThis, ADLX_I2C_LINE line, adlx_int address, adlx_bool* isSupported);
+    ADLX_RESULT(ADLX_STD_CALL *Read)(IADLXI2C* pThis, ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data);
+    ADLX_RESULT(ADLX_STD_CALL *RepeatedStartRead)(IADLXI2C* pThis, ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data);
+    ADLX_RESULT(ADLX_STD_CALL *Write)(IADLXI2C* pThis, ADLX_I2C_LINE line, adlx_int speed, adlx_int address, adlx_int offset, adlx_int dataSize, adlx_byte* data);
+
+}IADLXI2CVtbl;
+
+struct IADLXI2C { const IADLXI2CVtbl *pVtbl; };
+#endif //__cplusplus
+#pragma endregion IADLXI2C
+
+#endif //ADLX_II2C_H

package/src/includes/adlx/ILog.h

@@ -0,0 +1,72 @@
+// 
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+//-------------------------------------------------------------------------------------------------
+//ILog.h - Interfaces for ADLX log functionality
+#ifndef ADLX_LOG_H
+#define ADLX_LOG_H
+#pragma once
+
+#include "ADLXDefines.h"
+
+#pragma region IADLXLog interface
+#if defined (__cplusplus)
+
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXLog
+    {
+    public:
+        /**
+         * @page DOX_IADLXLog_WriteLog WriteLog
+         * @ENG_START_DOX
+         * @brief The __WriteLog__ method is called by ADLX when a new ADLX log message is available.
+         * @ENG_END_DOX
+         * @syntax
+         * @codeStart
+         *  @ref ADLX_RESULT    WriteLog (const wchar_t* msg)
+         * @codeEnd
+         *
+         * @params
+         * @paramrow{1.,[out], msg, const wchar_t*, @ENG_START_DOX The new log message from the internal code execution of ADLX. @ENG_END_DOX}
+         *
+         * @retvalues
+         * @ENG_START_DOX
+         * The method must return __ADLX_OK__.<br>
+         * @ENG_END_DOX
+         *
+         * @detaileddesc
+         * @ENG_START_DOX
+         * @details Once the application enables the ADLX logs with @ref DOX_IADLXSystem_EnableLog using __APPLICATION__ for the @ref ADLX_LOG_DESTINATION parameter, ADLX will call this method when a new log trace is generated. <br>
+		 * The method should return quickly to not block the execution path in ADLX. If the method requires a long processing of the log trace, the application must copy the log message and process it asynchronously.
+         * @ENG_END_DOX
+         *
+         * @copydoc IADLXLog_REQ_TABLE
+         *
+         * @seealso
+         * @ref DOX_IADLXSystem_EnableLog
+         */
+        virtual ADLX_RESULT ADLX_STD_CALL WriteLog (const wchar_t* msg) = 0;
+    }; //IADLXLog
+}
+#else
+ADLX_DECLARE_IID (IADLXLog, L"IADLXLog");
+typedef struct IADLXLog IADLXLog;
+
+typedef struct IADLXLogVtbl
+{
+    //IADLXLog
+    ADLX_RESULT (ADLX_STD_CALL *WriteLog)(IADLXLog* pThis, const wchar_t* msg);
+} IADLXLogVtbl;
+
+struct IADLXLog
+{
+    const IADLXLogVtbl *pVtbl;
+};
+
+#endif
+#pragma region IADLXLog interface
+
+#endif  //ADLX_LOG_H