SLABHIDtoUART.h

// SLABHIDtoUART.h
// For SLABHIDtoUART.dll
// and Silicon Labs CP2110/CP2114 HID to UART
#ifndef HOST_LIB_SLABHIDUART_INCLUDE_SLABHIDTOUART_H_INCLUDED_XF4QYQM3BK
#define HOST_LIB_SLABHIDUART_INCLUDE_SLABHIDTOUART_H_INCLUDED_XF4QYQM3BK


// Includes

#include    "silabs_defs.h"
#include    "silabs_sal.h"
#include "Types.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_UART_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_UART_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#if defined(HID_TO_UART_EXPORTS)
#define HID_TO_UART_API
#else
#if defined(SILABS_STATIC_LINK)
#define HID_TO_UART_API extern
#pragma comment(lib, "SLABHIDtoUART.static.lib")
#else // defined(SILABS_STATIC_LINK)
#define HID_TO_UART_API __declspec(dllimport)
#pragma comment(lib, "SLABHIDtoUART.lib")
#endif // defined(SILABS_STATIC_LINK)
#endif // defined(HID_TO_UART_EXPORTS)
#else // !_WIN32
#define HID_TO_UART_API 
#define WINAPI 
#endif // !_WIN32



// Return Code Definitions

#if !defined(USE_LEGACY_HID_UART_STATUS)
typedef enum _HID_UART_STATUS {
    HID_UART_SUCCESS                    = 0x00  
    , HID_UART_DEVICE_NOT_FOUND         = 0x01                  
    , HID_UART_INVALID_HANDLE           = 0x02                  
    , HID_UART_INVALID_DEVICE_OBJECT    = 0x03                  
    , HID_UART_INVALID_PARAMETER        = 0x04                  
    , HID_UART_INVALID_REQUEST_LENGTH   = 0x05                  

    , HID_UART_READ_ERROR               = 0x10                  
    , HID_UART_WRITE_ERROR              = 0x11                  
    , HID_UART_READ_TIMED_OUT           = 0x12                  
    , HID_UART_WRITE_TIMED_OUT          = 0x13                  
    , HID_UART_DEVICE_IO_FAILED         = 0x14                  
    , HID_UART_DEVICE_ACCESS_ERROR      = 0x15                  
    , HID_UART_DEVICE_NOT_SUPPORTED     = 0x16                  
    , HID_UART_INVALID_CONFIG_VERSION   = 0x17                  

    , HID_UART_DEVICE_ALREADY_OPENED    = 0x22                  

    , HID_UART_UNKNOWN_ERROR            = SILABS_STATUS_UNKNOWN_ERROR                   
} HID_UART_STATUS, *PHID_UART_STATUS;
#else // defined(USE_LEGACY_HID_UART_STATUS)
typedef int HID_UART_STATUS;
// API Status Return Codes
#define HID_UART_SUCCESS                                    0x00    
#define HID_UART_DEVICE_NOT_FOUND                   0x01 
#define HID_UART_INVALID_HANDLE                     0x02 
#define HID_UART_INVALID_DEVICE_OBJECT              0x03 
#define HID_UART_INVALID_PARAMETER                  0x04 
#define HID_UART_INVALID_REQUEST_LENGTH             0x05 

#define HID_UART_READ_ERROR                         0x10 
#define HID_UART_WRITE_ERROR                        0x11 
#define HID_UART_READ_TIMED_OUT                     0x12 
#define HID_UART_WRITE_TIMED_OUT                    0x13 
#define HID_UART_DEVICE_IO_FAILED                   0x14 
#define HID_UART_DEVICE_ACCESS_ERROR                0x15 
#define HID_UART_DEVICE_NOT_SUPPORTED               0x16 
#define HID_UART_INVALID_CONFIG_VERSION             0x17 

#define HID_UART_UNKNOWN_ERROR                      SILABS_STATUS_UNKNOWN_ERROR 
#endif // defined(USE_LEGACY_HID_UART_STATUS)

// String Definitions

#define HID_UART_GET_VID_STR                        0x01    
#define HID_UART_GET_PID_STR                        0x02    
#define HID_UART_GET_PATH_STR                       0x03    
#define HID_UART_GET_SERIAL_STR                     0x04    
#define HID_UART_GET_MANUFACTURER_STR               0x05    
#define HID_UART_GET_PRODUCT_STR                    0x06    

// String Lengths
#define HID_UART_DEVICE_STRLEN                      260     
typedef char HID_UART_DEVICE_STR[HID_UART_DEVICE_STRLEN];

// UART Definitions

#define HID_UART_PARITY_ERROR                       0x01    
#define HID_UART_OVERRUN_ERROR                      0x02    

#define HID_UART_LINE_BREAK_INACTIVE                0x00    
#define HID_UART_LINE_BREAK_ACTIVE                  0x01    

#define HID_UART_FIVE_DATA_BITS                     0x00    
#define HID_UART_SIX_DATA_BITS                      0x01    
#define HID_UART_SEVEN_DATA_BITS                    0x02    
#define HID_UART_EIGHT_DATA_BITS                    0x03    

#define HID_UART_NO_PARITY                          0x00    
#define HID_UART_ODD_PARITY                         0x01    
#define HID_UART_EVEN_PARITY                        0x02    
#define HID_UART_MARK_PARITY                        0x03    
#define HID_UART_SPACE_PARITY                       0x04    

#define HID_UART_SHORT_STOP_BIT                     0x00    
#define HID_UART_LONG_STOP_BIT                      0x01    

#define HID_UART_NO_FLOW_CONTROL                    0x00    
#define HID_UART_RTS_CTS_FLOW_CONTROL               0x01    

// Read/Write Limits
#define HID_UART_MIN_READ_SIZE                      1       
#define HID_UART_MAX_READ_SIZE                      32768   
#define HID_UART_MIN_WRITE_SIZE                     1       
#define HID_UART_MAX_WRITE_SIZE                     4096    

// User Customization Definitions

// User-Customizable Field Lock Bitmasks
#define HID_UART_LOCK_PRODUCT_STR_1                 0x0001  
#define HID_UART_LOCK_PRODUCT_STR_2                 0x0002  
#define HID_UART_LOCK_SERIAL_STR                    0x0004  
#define HID_UART_LOCK_PIN_CONFIG                    0x0008  
#define HID_UART_LOCK_VID                           0x0100  
#define HID_UART_LOCK_PID                           0x0200  
#define HID_UART_LOCK_POWER                         0x0400  
#define HID_UART_LOCK_POWER_MODE                    0x0800  
#define HID_UART_LOCK_RELEASE_VERSION               0x1000  
#define HID_UART_LOCK_FLUSH_BUFFERS                 0x2000  
#define HID_UART_LOCK_MFG_STR_1                     0x4000  
#define HID_UART_LOCK_MFG_STR_2                     0x8000  

// Field Lock Bit Values
#define HID_UART_LOCK_UNLOCKED                      1   
#define HID_UART_LOCK_LOCKED                        0   

#define HID_UART_BUS_POWER_MAX                      0xFA 

#define HID_UART_BUS_POWER                          0x00    
#define HID_UART_SELF_POWER_VREG_DIS                0x01    
#define HID_UART_SELF_POWER_VREG_EN                 0x02    

#define HID_UART_FLUSH_TX_OPEN                      0x01    
#define HID_UART_FLUSH_TX_CLOSE                     0x02    
#define HID_UART_FLUSH_RX_OPEN                      0x04    
#define HID_UART_FLUSH_RX_CLOSE                     0x08    

#define HID_UART_SET_VID                            0x01    
#define HID_UART_SET_PID                            0x02    
#define HID_UART_SET_POWER                          0x04    
#define HID_UART_SET_POWER_MODE                     0x08    
#define HID_UART_SET_RELEASE_VERSION                0x10    
#define HID_UART_SET_FLUSH_BUFFERS                  0x20    

#define HID_UART_SET_IGNORE                         0   
#define HID_UART_SET_PROGRAM                        1   

#define HID_UART_MFG_STRLEN                         62  
#define HID_UART_PRODUCT_STRLEN                     62  
#define HID_UART_SERIAL_STRLEN                      30  

typedef char HID_UART_MFG_STR[HID_UART_MFG_STRLEN];

typedef char HID_UART_PRODUCT_STR[HID_UART_PRODUCT_STRLEN];

typedef char HID_UART_SERIAL_STR[HID_UART_SERIAL_STRLEN];

// Pin Definitions

#define HID_UART_GPIO_MODE_INPUT                    0x00    
#define HID_UART_GPIO_MODE_OUTPUT_OD                0x01    
#define HID_UART_GPIO_MODE_OUTPUT_PP                0x02    
#define HID_UART_GPIO_MODE_FUNCTION1                0x03    
#define HID_UART_GPIO_MODE_FUNCTION2                0x04    

#define HID_UART_VALUE_SUSPEND_LO                   0   
#define HID_UART_VALUE_SUSPEND_HI                   1   

#define HID_UART_MODE_SUSPEND_OD                    0   
#define HID_UART_MODE_SUSPEND_PP                    1   

#define HID_UART_MODE_RS485_ACTIVE_LO               0x00    
#define HID_UART_MODE_RS485_ACTIVE_HI               0x01    

// Typedefs
typedef void* HID_UART_DEVICE;
typedef unsigned char U8;
typedef unsigned short U16;

// Exported Library Functions

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

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetNumDevices(_Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ LPDWORD lpdwNumDevices, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_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 DWORD options);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetOpenedString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* deviceString, _In_ _Pre_defensive_ const DWORD options);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_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);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetOpenedIndexedString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const DWORD stringIndex, char* deviceString);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_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* pDeviceReleaseNumber);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetOpenedAttributes(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pDeviceVid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pDevicePid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pDeviceReleaseNumber);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_Open(_Out_ HID_UART_DEVICE* pdevice, _In_ _Pre_defensive_ const DWORD deviceNum, _In_ _Pre_defensive_ const WORD vid, _In_ _Pre_defensive_ const WORD pid);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_Close(_In_ _Pre_defensive_ const HID_UART_DEVICE device);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_IsOpened(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* pbIsOpened);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetUartEnable(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const BOOL enable);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetUartEnable(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(BOOL)) _Pre_defensive_ BOOL* penable);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_Read(_In_ _Pre_defensive_ const HID_UART_DEVICE device, BYTE* buffer, _In_ _Pre_defensive_ const DWORD numBytesToRead, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* pNumBytesRead);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_Write(_In_ _Pre_defensive_ const HID_UART_DEVICE device, BYTE* buffer, _In_ _Pre_defensive_ const DWORD numBytesToWrite, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* pNumBytesWritten);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_FlushBuffers(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const BOOL bFlushTransmit, _In_ _Pre_defensive_ const BOOL bFlushReceive);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_CancelIo(_In_ _Pre_defensive_ const HID_UART_DEVICE device);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetTimeouts(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const DWORD ReadTimeoutInMilliseconds, _In_ _Pre_defensive_ const DWORD WriteTimeoutInMilliseconds);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetTimeouts(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* pReadTimeoutInMilliseconds, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* pWriteTimeoutInMilliseconds);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetUartStatus(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* transmitFifoSize, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* receiveFifoSize, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* errorStatus, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* lineBreakStatus);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetUartConfig(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const DWORD baudRate, _In_ _Pre_defensive_ const BYTE dataBits, _In_ _Pre_defensive_ const BYTE parity, _In_ _Pre_defensive_ const BYTE stopBits, _In_ _Pre_defensive_ const BYTE flowControl);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetUartConfig(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(DWORD)) _Pre_defensive_ DWORD* pBaudRate, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pDataBits, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pParity, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pStopBits, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pFlowControl);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_StartBreak(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const BYTE DurationInMilliseconds);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_StopBreak(_In_ _Pre_defensive_ const HID_UART_DEVICE device);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_Reset(_In_ _Pre_defensive_ const HID_UART_DEVICE device);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_ReadLatch(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pLatchValue);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_WriteLatch(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const WORD LatchValue, _In_ _Pre_defensive_ const WORD LatchMask);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetPartNumber(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pPartNumber, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pVersion);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetLibraryVersion(_Out_writes_bytes_(1) BYTE* pMajor, _Out_writes_bytes_(1) BYTE* pMinor, _Out_writes_bytes_(sizeof(BOOL)) BOOL* pIsReleaseBuild);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetHidLibraryVersion(_Out_writes_bytes_(1) BYTE* pMajor, _Out_writes_bytes_(1) BYTE* pMinor, _Out_writes_bytes_(sizeof(BOOL)) BOOL* pIsReleaseBuild);

#ifdef _WIN32
#endif
_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetHidGuid(_Out_ void* pHIDGuid);
#ifdef _WIN32

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetHidGuidSafe(_Out_ GUID *pHIDGuid);
#endif  // _WIN32

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetLock(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ _Pre_defensive_ const WORD lock);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetLock(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* lock);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetUsbConfig(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _In_ const WORD vid, _In_ const WORD pid, _In_ const BYTE power, _In_ const BYTE powerMode, _In_ const WORD releaseVersion, _In_ const BYTE flushBuffers, _In_ const BYTE mask);


_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetUsbConfig(_In_ _Pre_defensive_ const HID_UART_DEVICE device, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pVid, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pPid, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pPower, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pPowerMode, _Out_writes_bytes_(sizeof(WORD)) _Pre_defensive_ WORD* pReleaseVersion, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* pFlushBuffers);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetManufacturingString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* manufacturingString, _In_ _Pre_defensive_ const BYTE strlen);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetManufacturingString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* manufacturingString, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetProductString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* productString, _In_ _Pre_defensive_ const BYTE strlen);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetProductString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* productString, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_SetSerialString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* serialString, _In_ _Pre_defensive_ const BYTE strlen);

_Check_return_
_Ret_range_(HID_UART_SUCCESS, HID_UART_UNKNOWN_ERROR)
_Success_(return == HID_UART_SUCCESS)
HID_TO_UART_API HID_UART_STATUS WINAPI
HidUart_GetSerialString(_In_ _Pre_defensive_ const HID_UART_DEVICE device, char* serialString, _Out_writes_bytes_(sizeof(BYTE)) _Pre_defensive_ BYTE* strlen);

#ifdef __cplusplus
}
#endif // __cplusplus


#endif // HOST_LIB_SLABHIDUART_INCLUDE_SLABHIDTOUART_H_INCLUDED_XF4QYQM3BK