SLABCP2112.h

// SLABCP2112.h
// For SLABHIDtoSMBus.dll
// and Silicon Labs CP2112 HID to SMBus
#ifndef HOST_LIB_SLABHIDSMBUS_INCLUDE_SLABCP2112_H_INCLUDED_QU4N7WC20W
#define HOST_LIB_SLABHIDSMBUS_INCLUDE_SLABCP2112_H_INCLUDED_QU4N7WC20W

// Includes

#include "Types.h"
#include    "silabs_defs.h"
#include    "silabs_sal.h"

// Tool-chain-dependent hacks
#ifdef _WIN32
// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the HID_TO_SMBUS_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// HID_TO_SMBUS_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#if defined(HID_TO_SMBUS_EXPORTS)
#define HID_TO_SMBUS_API
#else
#define HID_TO_SMBUS_API __declspec(dllimport)
#pragma comment(lib, "SLABHIDtoSMBus.lib")
#endif // defined(HID_TO_SMBUS_EXPORTS)
#else // !_WIN32
#define HID_TO_SMBUS_API 
#define WINAPI 
#endif // !_WIN32


// Return Code Definitions

// HID_SMBUS_STATUS
#if defined(NOT_YET)
typedef enum _HID_SMBUS_STATUS {
    HID_SMBUS_SUCCESS = SILABS_STATUS_SUCCESS           
    , HID_SMBUS_DEVICE_NOT_FOUND = 0x01                 
    , HID_SMBUS_INVALID_HANDLE = 0x02                   
    , HID_SMBUS_INVALID_DEVICE_OBJECT = 0x03
    , HID_SMBUS_INVALID_PARAMETER = 0x04                
    , HID_SMBUS_INVALID_REQUEST_LENGTH = 0x05

    , HID_SMBUS_DEVICE_ALREADY_OPENED = SILABS_STATUS_DEVICE_ALREADY_OPENED 

    , HID_SMBUS_READ_ERROR = 0x10
    , HID_SMBUS_WRITE_ERROR = 0x11
    , HID_SMBUS_READ_TIMED_OUT = 0x12
    , HID_SMBUS_WRITE_TIMED_OUT = 0x13
    , HID_SMBUS_DEVICE_IO_FAILED = 0x14
    , HID_SMBUS_DEVICE_ACCESS_ERROR = 0x15
    , HID_SMBUS_DEVICE_NOT_SUPPORTED = 0x16

    , HID_SMBUS_UNKNOWN_ERROR = SILABS_STATUS_UNKNOWN_ERROR 
} HID_SMBUS_STATUS, *PHID_SMBUS_STATUS;
#else // defined(NOT_YET)
typedef int HID_SMBUS_STATUS;

// HID_SMBUS_STATUS Return Codes
#define HID_SMBUS_SUCCESS                           SILABS_STATUS_SUCCESS   
#define HID_SMBUS_DEVICE_NOT_FOUND                  0x01                    
#define HID_SMBUS_INVALID_HANDLE                    0x02                    
#define HID_SMBUS_INVALID_DEVICE_OBJECT             0x03                    
#define HID_SMBUS_INVALID_PARAMETER                 0x04                    
#define HID_SMBUS_INVALID_REQUEST_LENGTH            0x05                    

#define HID_SMBUS_DEVICE_ALREADY_OPENED             SILABS_STATUS_DEVICE_ALREADY_OPENED 

#define HID_SMBUS_READ_ERROR                        0x10                    
#define HID_SMBUS_WRITE_ERROR                       0x11                    
#define HID_SMBUS_READ_TIMED_OUT                    0x12                    
#define HID_SMBUS_WRITE_TIMED_OUT                   0x13                    
#define HID_SMBUS_DEVICE_IO_FAILED                  0x14                    
#define HID_SMBUS_DEVICE_ACCESS_ERROR               0x15                    
#define HID_SMBUS_DEVICE_NOT_SUPPORTED              0x16                    

#define HID_SMBUS_UNKNOWN_ERROR                     SILABS_STATUS_UNKNOWN_ERROR                 
#endif // defined(NOT_YET)
typedef BYTE HID_SMBUS_S0;

#define HID_SMBUS_S0_IDLE                           0x00    
#define HID_SMBUS_S0_BUSY                           0x01    
#define HID_SMBUS_S0_COMPLETE                       0x02    
#define HID_SMBUS_S0_ERROR                          0x03    

typedef BYTE HID_SMBUS_S1;

// HID_SMBUS_TRANSFER_S0 = HID_SMBUS_S0_BUSY
#define HID_SMBUS_S1_BUSY_ADDRESS_ACKED             0x00    
#define HID_SMBUS_S1_BUSY_ADDRESS_NACKED            0x01    
#define HID_SMBUS_S1_BUSY_READING                   0x02    
#define HID_SMBUS_S1_BUSY_WRITING                   0x03    

// HID_SMBUS_TRANSFER_S0 = HID_SMBUS_S0_ERROR
#define HID_SMBUS_S1_ERROR_TIMEOUT_NACK             0x00    
#define HID_SMBUS_S1_ERROR_TIMEOUT_BUS_NOT_FREE     0x01    
#define HID_SMBUS_S1_ERROR_ARB_LOST                 0x02    
#define HID_SMBUS_S1_ERROR_READ_INCOMPLETE          0x03    
#define HID_SMBUS_S1_ERROR_WRITE_INCOMPLETE         0x04    
#define HID_SMBUS_S1_ERROR_SUCCESS_AFTER_RETRY      0x05    

// String Definitions
typedef enum _HID_SMBUS_GETSTRING {
    HID_SMBUS_GET_VID_STR = 0x01    
    , HID_SMBUS_GET_PID_STR = 0x02  
    , HID_SMBUS_GET_PATH_STR = 0x03 
    , HID_SMBUS_GET_SERIAL_STR = 0x04   
    , HID_SMBUS_GET_MANUFACTURER_STR = 0x05 
    , HID_SMBUS_GET_PRODUCT_STR = 0x06  
} HID_SMBUS_GETSTRING, *PHID_SMBUS_GETSTRING;
_Check_return_
_Success_(return == TRUE)
__inline static bool IsValidHID_SMBUS_GETSTRING(_In_ const HID_SMBUS_GETSTRING _s) { return (HID_SMBUS_GET_VID_STR == _s) || (HID_SMBUS_GET_PID_STR == _s) || (HID_SMBUS_GET_PATH_STR == _s) || (HID_SMBUS_GET_SERIAL_STR == _s) || (HID_SMBUS_GET_MANUFACTURER_STR == _s) || (HID_SMBUS_GET_PRODUCT_STR == _s); }

// String Lengths
#define HID_SMBUS_DEVICE_STRLEN                     260 

typedef char HID_SMBUS_DEVICE_STR[HID_SMBUS_DEVICE_STRLEN];

// SMBUS Definitions

// SMbus Configuration Limits
#define HID_SMBUS_MIN_BIT_RATE                      1 
#define HID_SMBUS_MIN_TIMEOUT                       0 
#define HID_SMBUS_MAX_TIMEOUT                       1000 
#define HID_SMBUS_MAX_RETRIES                       1000 
#define HID_SMBUS_MIN_ADDRESS                       0x02 
#define HID_SMBUS_MAX_ADDRESS                       0xFE 

// Read/Write Limits
#define HID_SMBUS_MIN_READ_REQUEST_SIZE             1 
#define HID_SMBUS_MAX_READ_REQUEST_SIZE             512 
#define HID_SMBUS_MIN_TARGET_ADDRESS_SIZE           1 
#define HID_SMBUS_MAX_TARGET_ADDRESS_SIZE           16 
#define HID_SMBUS_MAX_READ_RESPONSE_SIZE            61 
#define HID_SMBUS_MIN_WRITE_REQUEST_SIZE            1 
#define HID_SMBUS_MAX_WRITE_REQUEST_SIZE            61 

// GPIO Definitions

// GPIO Pin Direction Bit Value
#define HID_SMBUS_DIRECTION_INPUT                   0   
#define HID_SMBUS_DIRECTION_OUTPUT                  1   

// GPIO Pin Mode Bit Value
#define HID_SMBUS_MODE_OPEN_DRAIN                   0   
#define HID_SMBUS_MODE_PUSH_PULL                    1   

// GPIO Function Bitmask
#define HID_SMBUS_MASK_FUNCTION_GPIO_7_CLK          0x01    
#define HID_SMBUS_MASK_FUNCTION_GPIO_0_TXT          0x02    
#define HID_SMBUS_MASK_FUNCTION_GPIO_1_RXT          0x04    

// GPIO Function Bit Value
#define HID_SMBUS_GPIO_FUNCTION                     0   
#define HID_SMBUS_SPECIAL_FUNCTION                  1   

// GPIO Pin Bitmask
#define HID_SMBUS_MASK_GPIO_0                       0x01 
#define HID_SMBUS_MASK_GPIO_1                       0x02 
#define HID_SMBUS_MASK_GPIO_2                       0x04 
#define HID_SMBUS_MASK_GPIO_3                       0x08 
#define HID_SMBUS_MASK_GPIO_4                       0x10 
#define HID_SMBUS_MASK_GPIO_5                       0x20 
#define HID_SMBUS_MASK_GPIO_6                       0x40 
#define HID_SMBUS_MASK_GPIO_7                       0x80 

// Part Number Definitions

#define HID_SMBUS_PART_CP2112                       CP210x_PARTNUM_CP2112 

// User Customization Definitions
//@brief  User-Customizable Field Lock Bitmasks
typedef enum _HID_SMBUS_LOCKBITS {
    HID_SMBUS_LOCK_VID = ((BYTE)(0xFF & 0x01))                  
    , HID_SMBUS_LOCK_PID = ((BYTE)(0xFF & 0x02))                
    , HID_SMBUS_LOCK_POWER = ((BYTE)(0xFF & 0x04))              
    , HID_SMBUS_LOCK_POWER_MODE = ((BYTE)(0xFF & 0x08))         
    , HID_SMBUS_LOCK_RELEASE_VERSION = ((BYTE)(0xFF & 0x10))    
    , HID_SMBUS_LOCK_MFG_STR = ((BYTE)(0xFF & 0x20))            
    , HID_SMBUS_LOCK_PRODUCT_STR = ((BYTE)(0xFF & 0x40))        
    , HID_SMBUS_LOCK_SERIAL_STR = ((BYTE)(0xFF & 0x80))         
} HID_SMBUS_LOCKBITS, *PHID_SMBUS_LOCKBITS;
_Check_return_
_Success_(return == TRUE)
__inline static bool IsValidHID_SMBUS_HID_SMBUS_LOCKBITS(_In_ const HID_SMBUS_LOCKBITS _s)
{
    return (HID_SMBUS_LOCK_VID == _s) || (HID_SMBUS_LOCK_PID == _s)
        || (HID_SMBUS_LOCK_POWER == _s) || (HID_SMBUS_LOCK_POWER_MODE == _s)
        || (HID_SMBUS_LOCK_RELEASE_VERSION == _s)
        || (HID_SMBUS_LOCK_MFG_STR == _s) || (HID_SMBUS_LOCK_PRODUCT_STR == _s) || (HID_SMBUS_LOCK_SERIAL_STR == _s);
}

// Field Lock Bit Values
#define HID_SMBUS_LOCK_UNLOCKED                     1   
#define HID_SMBUS_LOCK_LOCKED                       0   

// Power Max Value (500 mA)
#define HID_SMBUS_BUS_POWER_MAX                     0xFA    

// Power Modes
#define HID_SMBUS_BUS_POWER                         0x00    
#define HID_SMBUS_SELF_POWER_VREG_DIS               0x01    
#define HID_SMBUS_SELF_POWER_VREG_EN                0x02    

// USB Config Bitmasks
#define HID_SMBUS_SET_VID                           0x01    
#define HID_SMBUS_SET_PID                           0x02    
#define HID_SMBUS_SET_POWER                         0x04    
#define HID_SMBUS_SET_POWER_MODE                    0x08    
#define HID_SMBUS_SET_RELEASE_VERSION               0x10    

// USB Config Bit Values
#define HID_SMBUS_SET_IGNORE                        0 
#define HID_SMBUS_SET_PROGRAM                       1 

// String Lengths
#define HID_SMBUS_CP2112_MFG_STRLEN                 30 
#define HID_SMBUS_CP2112_PRODUCT_STRLEN             30 
#define HID_SMBUS_CP2112_SERIAL_STRLEN              30 
typedef char HID_SMBUS_CP2112_MFG_STR[HID_SMBUS_CP2112_MFG_STRLEN];
typedef char HID_SMBUS_CP2112_PRODUCT_STR[HID_SMBUS_CP2112_PRODUCT_STRLEN];
typedef char HID_SMBUS_CP2112_SERIAL_STR[HID_SMBUS_CP2112_SERIAL_STRLEN];

// Typedefs
typedef void* HID_SMBUS_DEVICE;

// Exported Library Functions

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

// HidSmbus_GetNumDevices
    HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetNumDevices(_Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* lpdwNumDevices, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid);

// HidSmbus_GetString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetString(_In_ _Pre_defensive_ const DWORD deviceNum, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid, _Out_ _Pre_defensive_ char* deviceString, _In_ _Pre_defensive_ const HID_SMBUS_GETSTRING options);

// HidSmbus_GetOpenedString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetOpenedString(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, char* deviceString, _In_ _Pre_defensive_ const HID_SMBUS_GETSTRING options);

// HidSmbus_GetIndexedString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetIndexedString(_In_ _Pre_defensive_ const DWORD deviceNum, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid, _In_ _Pre_defensive_ const DWORD stringIndex, char* deviceString);

// HidSmbus_GetOpenedIndexedString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetOpenedIndexedString(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_ _Pre_defensive_ const DWORD stringIndex, char* deviceString);

// HidSmbus_GetAttributes
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetAttributes(_In_ _Pre_defensive_ const DWORD deviceNum, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* deviceVid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* devicePid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* deviceReleaseNumber);

// HidSmbus_GetOpenedAttributes
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetOpenedAttributes(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* deviceVid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* devicePid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* deviceReleaseNumber);

// HidSmbus_Open
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_Open(_Out_writes_bytes_(sizeof(HID_SMBUS_DEVICE*)) _Pre_defensive_ HID_SMBUS_DEVICE* pdevice, _In_ _Pre_defensive_ const DWORD deviceNum, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid);

// HidSmbus_Close
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_Close(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device);

// HidSmbus_IsOpened
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_IsOpened(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* bIsOpened);

// HidSmbus_ReadRequest
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_ReadRequest(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_range_(0x02,0xFE) _Pre_defensive_ const BYTE slaveAddress, _In_range_(1, 512) _Pre_defensive_ const WORD numBytesToRead);

// HidSmbus_AddressReadRequest
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_AddressReadRequest(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_range_(0x02, 0xFE)  _Pre_defensive_ const BYTE slaveAddress, _In_range_(1, 512) _Pre_defensive_ const WORD numBytesToRead, _In_range_(1, 16) _Pre_defensive_ const BYTE targetAddressSize, BYTE targetAddress[16]);

// HidSmbus_ForceReadResponse
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_ForceReadResponse(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_range_(1, 512) _Pre_defensive_ const WORD numBytesToRead);

// HidSmbus_GetReadResponse
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetReadResponse(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(HID_SMBUS_S0)) _Pre_defensive_ HID_SMBUS_S0* status,
    _Out_writes_bytes_(sizeof(bufferSize)) _Pre_defensive_ BYTE* buffer,
    _In_ _Pre_defensive_ const BYTE bufferSize,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* numBytesRead
);

// HidSmbus_WriteRequest
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_WriteRequest(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_range_(0x02, 0xFE) _Pre_defensive_ const BYTE slaveAddress,
    _In_reads_bytes_(numBytesToWrite) _Pre_defensive_ BYTE* buffer,
    _In_range_(1, 61)   _Pre_defensive_ const BYTE numBytesToWrite
);

// HidSmbus_TransferStatusRequest
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_TransferStatusRequest(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device);

// HidSmbus_GetTransferStatusResponse
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetTransferStatusResponse(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(HID_SMBUS_S0)) _Pre_defensive_ HID_SMBUS_S0* status,
    _Out_writes_bytes_(sizeof(HID_SMBUS_S1)) _Pre_defensive_ HID_SMBUS_S1* detailedStatus,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* numRetries,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* bytesRead
);

// HidSmbus_CancelTransfer
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_CancelTransfer(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device);

// HidSmbus_CancelIo
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_CancelIo(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device);

// HidSmbus_SetTimeouts
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetTimeouts(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_ _Pre_defensive_ const DWORD responseTimeout);

// HidSmbus_GetTimeouts
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetTimeouts(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* responseTimeout);

// HidSmbus_SetSmbusConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetSmbusConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_ _Pre_defensive_ const DWORD bitRate,
    _In_range_(HID_SMBUS_MIN_ADDRESS, HID_SMBUS_MAX_ADDRESS) _Pre_defensive_ const BYTE address,
    _In_ _Pre_defensive_ const BOOL autoReadRespond,
    _In_range_(HID_SMBUS_MIN_TIMEOUT, HID_SMBUS_MAX_TIMEOUT) _Pre_defensive_ const WORD writeTimeout,
    _In_range_(HID_SMBUS_MIN_TIMEOUT, HID_SMBUS_MAX_TIMEOUT) _Pre_defensive_ const WORD readTimeout,
    _In_ _Pre_defensive_ const BOOL sclLowTimeout,
    _In_range_(0, HID_SMBUS_MAX_RETRIES) _Pre_defensive_ const WORD transferRetries
);

// HidSmbus_GetSmbusConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetSmbusConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* bitRate,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* address,
    _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* autoReadRespond,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* writeTimeout,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* readTimeout,
    _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* sclLowtimeout,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* transferRetries
);

// HidSmbus_Reset
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_Reset(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device);

// HidSmbus_SetGpioConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetGpioConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_ _Pre_defensive_ const BYTE direction,
    _In_ _Pre_defensive_ const BYTE mode,
    _In_ _Pre_defensive_ const BYTE function,
    _In_ _Pre_defensive_ const BYTE clkDiv
);

// HidSmbus_GetGpioConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetGpioConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* direction,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* mode,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* function,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* clkDiv
);

// HidSmbus_ReadLatch
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_ReadLatch(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* latchValue);

// HidSmbus_WriteLatch
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_WriteLatch(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_ _Pre_defensive_ const BYTE latchValue,
    _In_ _Pre_defensive_ const BYTE latchMask
);

// HidSmbus_GetPartNumber
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetPartNumber(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* partNumber,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* version
);

// HidSmbus_GetLibraryVersion
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetLibraryVersion(_Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* major, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* minor, _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* bIsRelease);

// HidSmbus_GetHidLibraryVersion
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetHidLibraryVersion(_Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* major, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* minor, _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* bIsRelease);

// HidSmbus_GetHidGuid
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetHidGuid(_Out_ void* pHIDGuid);
// TODO: Enstone: Implement HidSmbus_GetHidGuidSafe(_Out_ GUID *pHIDGuid);

// Exported Library Functions - Device Customization

// HidSmbus_SetLock
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetLock(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _In_ _Pre_defensive_ const BYTE lock);

// HidSmbus_GetLock
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetLock(_In_ _Pre_defensive_ const HID_SMBUS_DEVICE device, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* lock);

// HidSmbus_SetUsbConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetUsbConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_ _Pre_defensive_ const WORD vid,
    _In_ _Pre_defensive_ const WORD pid,
    _In_range_(0, HID_SMBUS_BUS_POWER_MAX) _Pre_defensive_ const BYTE power,
    _In_ _Pre_defensive_ const BYTE powerMode,
    _In_ _Pre_defensive_ const WORD releaseVersion,
    _In_ _Pre_defensive_ const BYTE mask
);

// HidSmbus_GetUsbConfig
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetUsbConfig(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* vid,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pid,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* power,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* powerMode,
    _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* releaseVersion
);

// HidSmbus_SetManufacturingString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetManufacturingString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_reads_bytes_(strlen) _Pre_defensive_ char* manufacturingString,
    _In_range_(0, HID_SMBUS_CP2112_MFG_STRLEN) _Pre_defensive_ const BYTE strlen
);

// HidSmbus_GetManufacturingString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetManufacturingString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    char* manufacturingString,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen
);

// HidSmbus_SetProductString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetProductString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_reads_bytes_(strlen) _Pre_defensive_ char* productString,
    _In_range_(0, HID_SMBUS_CP2112_PRODUCT_STRLEN) _Pre_defensive_ const BYTE strlen
);

// HidSmbus_GetProductString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetProductString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    char* productString,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen
);

// HidSmbus_SetSerialString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_SetSerialString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    _In_reads_bytes_(strlen) _Pre_defensive_ char* serialString,
    _In_range_(0, HID_SMBUS_CP2112_SERIAL_STRLEN) _Pre_defensive_ const BYTE strlen
);

// HidSmbus_GetSerialString
_Check_return_
_Ret_range_(HID_SMBUS_SUCCESS, HID_SMBUS_UNKNOWN_ERROR)
_Success_(HID_SMBUS_SUCCESS)
HID_TO_SMBUS_API HID_SMBUS_STATUS WINAPI
HidSmbus_GetSerialString(
    _In_ _Pre_defensive_ const HID_SMBUS_DEVICE device,
    char* serialString,
    _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen
);

#ifdef __cplusplus
}
#endif // __cplusplus


#endif // HOST_LIB_SLABHIDSMBUS_INCLUDE_SLABCP2112_H_INCLUDED_QU4N7WC20W