Silicon Labs Host Libraries
SLAB_USB_SPI.h
1 //-----------------------------------------------------------------------------
2 // SLAB_USB_SPI.h
3 //-----------------------------------------------------------------------------
4 // Copyright 2012-2017 Silicon Laboratories Inc.
5 // http://www.silabs.com
6 //-----------------------------------------------------------------------------
7 
10 
11 #ifndef HOST_LIB_SLABUSBSPI_INCLUDE_SLAB_USB_SPI_H_INCLUDED_9QK7BKA9FX
12 #define HOST_LIB_SLABUSBSPI_INCLUDE_SLAB_USB_SPI_H_INCLUDED_9QK7BKA9FX
13 
17 
18 #include "silabs_defs.h"
19 #include "silabs_sal.h"
20 #include "Types.h"
21 
22 #ifdef _WIN32
23 // The following ifdef block is the standard way of creating macros which make exporting
24 // from a DLL simpler. All files within this DLL are compiled with the SI_USB_XP_EXPORTS
25 // symbol defined on the command line. this symbol should not be defined on any project
26 // that uses this DLL. This way any other project whose source files include this file see
27 // SI_USB_XP_API functions as being imported from a DLL, wheras this DLL sees symbols
28 // defined with this macro as being exported.
29 #ifdef SLAB_USB_SPI_EXPORTS
30 #define SLAB_USB_SPI_API
31 #else
32 #define SLAB_USB_SPI_API __declspec(dllimport)
33 #pragma comment (lib, "SLAB_USB_SPI.lib")
34 #endif // USB_SPI_EXPORTS
35 #else // !_WIN32
36 #define SLAB_USB_SPI_API
37 #define WINAPI
38 #endif // !_WIN32
39 
40 
42 // Definitions - Windows Definitions
46 
47 #define MAX_PATH 260
48 #define CALLBACK __stdcall
49 #ifndef WINAPI
50 #define WINAPI __stdcall
51 #endif
52 
55 // Variable types
58 typedef void* CP213x_DEVICE; // TODO: casting as a void * prevents the compiler from being able to help us find type-mismatches
59 
61 // Definitions specific to USB SPI code
65 
66 #define BULK_PACKETSIZE 64
67 #define EP_BUFSIZE BULK_PACKETSIZE
68 #define CMD_SIZE 8
69 #define CMD_TIMEOUT_MS 1000
70 #define STRING_DESCRIPTOR_SIZE 256
71 #define SIZE_PIN_CONFIG 20
72 
73 
74 // Maximum block size for WriteRead
75 #define WRITEREAD_MAX_BLOCKSIZE 256
76 
77 // Number of GPIO/CS pins
78 #define CP213x_NUM_GPIO 11
79 
80 // Chip Select Mode: 0: Idle, 1: Active, 2: Active; all other channels idle
81 #define CSMODE_IDLE 0
82 #define CSMODE_ACTIVE 1
83 #define CSMODE_ACTIVE_OTHERS_IDLE 2
84 
85 // Mode definitions for GPIO/CS/SpecialFunction pins
86 #define GPIO_MODE_INPUT 0
87 #define GPIO_MODE_OUTPUT_OD 1
88 #define GPIO_MODE_OUTPUT_PP 2
89 #define GPIO_MODE_CHIPSELECT 3
90 
91 #define GPIO_MODE__RTR_ACTLOW 4
92 #define GPIO_MODE__RTR_ACTHIGH 5
93 
94 #define GPIO_MODE__EVTCNTR_RISING 4
95 #define GPIO_MODE__EVTCNTR_FALLING 5
96 #define GPIO_MODE__EVTCNTR_NEGPULSE 6
97 #define GPIO_MODE__EVTCNTR_POSPULSE 7
98 
99 #define GPIO_MODE__CLK_OUT 4
100 #define GPIO_MODE__SPI_ACTIVITY 4
101 #define GPIO_MODE__SUSPEND 4
102 #define GPIO_MODE__SUSPENDBAR 4
103 
104 // End of GPIO Mode definitions
105 
106 
107 // String Buffer Definitions
108 #define SHORT_STRING_LEN 60
109 #define LONG_STRING_LEN_1 61
110 #define LONG_STRING_LEN_2 63
111 
113 // SPI Command and Subcommand definitions
116 
119 #define CMD_TRANSFER_DATA 0x0000
120  // Subcommand definitions for TRANSFER_DATA command
121  #define SUBCMD_READ 0
122  #define SUBCMD_WRITE 1
123  #define SUBCMD_WRITEREAD 2
124  #define SUBCMD_RTREAD 4
125  #define SUBCMD_MSB_RELEASE_BUS 0x80
126 _Check_return_
128 _Success_(return == TRUE)
129 static inline BOOL IsValidSubCmd(_In_ const BYTE SubCmd) {return (SUBCMD_READ == SubCmd) || (SUBCMD_WRITE == SubCmd) || (SUBCMD_WRITEREAD == SubCmd) || (SUBCMD_RTREAD == SubCmd);}
130 
133 // Bits 7-6: Not assigned
134 
135 // Bit 5: Clock phase (CPHA)
136 #define SPICTL_CPHA_SHIFT 5
137 #define SPICTL_CPHA_MASK 0x20
138 #define SPICTL_CPHA_LEADING_EDGE 0
139 #define SPICTL_CPHA_TRAILING_EDGE 1
140 
141 // Bit 4: Clock polarity (CPOL)
142 #define SPICTL_CPOL_SHIFT 4
143 #define SPICTL_CPOL_MASK 0x10
144 #define SPICTL_CPOL_ACTIVE_HIGH 0
145 #define SPICTL_CPOL_ACTIVE_LOW 1
146 
147 // Bit 3: Chip Select Mode
148 #define SPICTL_CSMODE_SHIFT 3
149 #define SPICTL_CSMODE_MASK 0x08
150 #define SPICTL_CSMODE_OPENDRAIN 0
151 #define SPICTL_CSMODE_PUSHPULL 1
152 
153 // Bit 2-0: Clock rate
154 #define SPICTL_CLKRATE_SHIFT 0
155 #define SPICTL_CLKRATE_MASK 0x07
156 #define SPICTL_CLKRATE_12M 0
157 #define SPICTL_CLKRATE_6M 1
158 #define SPICTL_CLKRATE_3M 2
159 #define SPICTL_CLKRATE_1M5 3
160 #define SPICTL_CLKRATE_750K 4
161 #define SPICTL_CLKRATE_375K 5
162 #define SPICTL_CLKRATE_187K5 6
163 #define SPICTL_CLKRATE_93K75 7
164 
166 // Error Definitions
169 
172 #define bRESULT_PASS TRUE
173 #define bRESULT_FAIL FALSE
174 
176 
178 typedef enum _USB_SPI_STATUS {
179 // CP2130 General Errors
180  USB_SPI_ERRCODE_SUCCESS = SILABS_STATUS_SUCCESS
181  , USB_SPI_ERRCODE_ALLOC_FAILURE = 0x01
182  , USB_SPI_ERRCODE_INVALID_ENUM_VALUE = 0x02
183  , USB_SPI_ERRCODE_NULL_POINTER = 0x03
184  , USB_SPI_ERRCODE_INVALID_CHANNEL_INDEX = 0x04
185  , USB_SPI_ERRCODE_INVALID_GPIO_MODE = 0x05
186 
187  , USB_SPI_ERRCODE_UNKNOWN_ERROR = 0xFFFFFFFF
188 
189 //
190 // API Errors
191 //
192  , USB_SPI_ERRCODE_INVALID_PARAMETER = 0x10
193 
194  , USB_SPI_ERRCODE_INVALID_DEVICE_OBJECT = 0x11
195 
196 //
197 // Device Errors
198 //
199  , USB_SPI_ERRCODE_DEVICE_NOT_FOUND = 0x20
200  , USB_SPI_ERRCODE_USB_DEVICE_NOT_OPENED = 0x21
201  , USB_SPI_ERRCODE_INVALID_HANDLE = 0x22
202 
203 //
204 // Device Hardware Interface Errors
205 //
206 
207  , USB_SPI_ERRCODE_HWIF_DEVICE_ERROR = 0x30
208 
209 
210  , USB_SPI_ERRCODE_HWIF_TRANSFER_TIMEOUT = 0x31
211 
212 // CP2130 Data Transfer Errors
213 
214  , USB_SPI_ERRCODE_CONTROL_TRANSFER_ERROR = 0x50
215  , USB_SPI_ERRCODE_INVALID_TRANSFER_SIZE = 0x51
216 
217  , USB_SPI_ERRCODE_PIPE_INIT_FAIL = 0x60
218  , USB_SPI_ERRCODE_PIPE_QUERY_FAIL = 0x61
219  , USB_SPI_ERRCODE_PIPE_WRITE_FAIL = 0x62
220  , USB_SPI_ERRCODE_PIPE_READ_FAIL = 0x63
221  , USB_SPI_ERRCODE_PIPE_ABORT_FAIL = 0x64
222  , USB_SPI_ERRCODE_PIPE_FLUSH_FAIL = 0x65
223  , USB_SPI_ERRCODE_PIPE_INVALID_ID = 0x66
224 
225  , USB_SPI_ERRCODE_READ_THREAD_CREATE_FAILURE = 0x70
226  , USB_SPI_ERRCODE_READ_THREAD_NOT_RUNNING = 0x71
227  , USB_SPI_ERRCODE_READ_THREAD_START_FAILURE = 0x72
228 
229  , USB_SPI_ERRCODE_DEVICE_RETURNED_TOO_MUCH_DATA = 0x80
230 
231  , USB_SPI_ERRCODE_SYSTEM_ERROR = 0xFFFFFFFE
232 } USB_SPI_STATUS, *PUSB_SPI_STATUS;
237 // User-Customizable Field Lock Bitmasks
238 #define CP213x_LOCK_PRODUCT_STR_1 0x0001
239 #define CP213x_LOCK_PRODUCT_STR_2 0x0002
240 #define CP213x_LOCK_SERIAL_STR 0x0004
241 #define CP213x_LOCK_PIN_CONFIG 0x0008
242 
243 #define CP213x_LOCK_VID 0x0100
244 #define CP213x_LOCK_PID 0x0200
245 #define CP213x_LOCK_POWER 0x0400
246 #define CP213x_LOCK_POWER_MODE 0x0800
247 #define CP213x_LOCK_RELEASE_VERSION 0x1000
248 #define CP213x_LOCK_MFG_STR_1 0x2000
249 #define CP213x_LOCK_MFG_STR_2 0x4000
250 #define CP213x_LOCK_TRANSFER_PRIORITY 0x8000
251 
252 // USB Config Bitmasks
253 #define CP213x_SET_VID 0x01
254 #define CP213x_SET_PID 0x02
255 #define CP213x_SET_POWER 0x04
256 #define CP213x_SET_POWER_MODE 0x08
257 #define CP213x_SET_RELEASE_VERSION 0x10
258 #define CP213x_SET_TRANSFER_PRIORITY 0x80
259 
260 // String Lengths
261 #define MFG_STRLEN 62
262 #define PRODUCT_STRLEN 62
263 #define SERIAL_STRLEN 30
264 
265 typedef char MFG_STR[MFG_STRLEN];
266 typedef char PRODUCT_STR[PRODUCT_STRLEN];
267 typedef char SERIAL_STR[SERIAL_STRLEN];
268 
270 // Enumerations
274 enum SET_STATUS {SET_SUCCESS, SET_FAIL, SET_VERIFY_FAIL};
275 
277 // Pin Definitions
279 
280 // Pin Config Mode Array Indices
281 #define CP213x_INDEX_GPIO_0 0
282 #define CP213x_INDEX_GPIO_1 1
283 #define CP213x_INDEX_GPIO_2 2
284 #define CP213x_INDEX_GPIO_3 3
285 #define CP213x_INDEX_GPIO_4 4
286 #define CP213x_INDEX_GPIO_5 5
287 #define CP213x_INDEX_GPIO_6 6
288 #define CP213x_INDEX_GPIO_7 7
289 #define CP213x_INDEX_GPIO_8 8
290 #define CP213x_INDEX_GPIO_9 9
291 #define CP213x_INDEX_GPIO_10 10
292 
293 // Pin Bitmasks
294 #define CP213x_MASK_SCK 0x0001
295 #define CP213x_MASK_MISO 0x0002
296 #define CP213x_MASK_MOSI 0x0004
297 #define CP213x_MASK_GPIO_0 0x0008
298 #define CP213x_MASK_GPIO_1 0x0010
299 #define CP213x_MASK_GPIO_2 0x0020
300 #define CP213x_MASK_GPIO_3 0x0040
301 #define CP213x_MASK_GPIO_4 0x0080
302 #define CP213x_MASK_GPIO_5 0x0100
303 #define CP213x_MASK_GPIO_6 0x0400
304 #define CP213x_MASK_GPIO_7 0x0800
305 #define CP213x_MASK_GPIO_8 0x1000
306 #define CP213x_MASK_GPIO_9 0x2000
307 #define CP213x_MASK_GPIO_10 0x4000
308 
309 
312 // Structures
314 
317 
320 typedef struct _DEVICE_DESCRIPTOR
321 {
322  BYTE bLength;
323  BYTE bDescriptorType;
324  WORD bcdUSB;
325  BYTE bDeviceClass;
326  BYTE bDeviceSubClass;
327  BYTE bDeviceProtocol;
328  BYTE bMaxPacketSize0;
329  WORD idVendor;
330  WORD idProduct;
331  WORD bcdDevice;
332  BYTE iManufacturer;
333  BYTE iProduct;
334  BYTE iSerialNumber;
335  BYTE bNumConfigurations;
336 } DEVICE_DESCRIPTOR, *PDEVICE_DESCRIPTOR;
341 typedef struct _SPI_CMD
342 {
343  WORD Cmd;
344  WORD SubCmd;
345  DWORD Len;
346  DWORD blockSize;
347  DWORD timeoutMs;
348  DWORD res;
349 } SPI_CMD, *PSPI_CMD;
352 
353 // Bitfield masks for delay_mode structure element
354 #define SPI_INTERBYTE_DELAY_MASK 0x01
355 #define SPI_CS_POSTASSERT_DELAY_MASK 0x02
356 #define SPI_CS_PREDEASSERT_DELAY_MASK 0x04
357 #define SPI_CS_TOGGLE_MASK 0x08
358 
359 
362 // Exported API Functions
364 
367 
368 #ifdef __cplusplus
369 extern "C" {
370 #endif // __cplusplus
371 
383 _Check_return_
384 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
385 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
386 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
387 CP213x_GetLibraryVersion (_Out_writes_bytes_opt_(1) BYTE* major, _Out_writes_bytes_opt_(1) BYTE* minor, _Out_writes_bytes_opt_(1) BOOL* release);
388 
389 //
390 // CP2130 Device Management
391 //
394 
405 _Check_return_
406 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
407 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
408 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
409 CP213x_GetGuid ( _Out_ LPGUID guid );
410 
421 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
422 CP213x_SetGuid ( LPGUID guid );
423 
424 #ifdef _WIN32
425 _Check_return_
436 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
437 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
438 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
439 CP213x_GetNumDevices ( _Out_writes_bytes_(4/*sizeof DWORD*/) DWORD* numDevices );
440 #else
441 USB_SPI_STATUS
454 CP213x_GetNumDevices ( DWORD* numDevices, DWORD VID, DWORD PID );
455 #endif
456 
468 _Check_return_
469 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
470 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
471 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
472 CP213x_GetDevicePath(_In_ const DWORD deviceIndex, _Out_writes_bytes_(MAX_PATH) LPSTR path);
473 
474 #ifdef _WIN32
475 _Check_return_
495 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
496 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
497 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
498 CP213x_OpenByIndex ( DWORD deviceIndex,
499  CP213x_DEVICE* phDevice );
500 
501 
516 _Check_return_
517 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
518 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
519 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
520 CP213x_OpenByDevicePath ( LPCSTR devicePath,
521  CP213x_DEVICE* phDevice );
522 
523 #else
524 USB_SPI_STATUS CP213x_Open(DWORD deviceIndex, CP213x_DEVICE* phDevice, DWORD VID, DWORD PID );
545 
546 #endif
547 
548 
561 _Check_return_
562 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
563 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
564 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
565 CP213x_GetVidPid(_In_ const DWORD deviceIndex, _Out_writes_bytes_(4/*sizeof DWORD*/) WORD* vid, _Out_writes_bytes_(4/*sizeof DWORD*/) WORD* pid );
566 
578 _Check_return_
579 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
580 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
581 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
582 CP213x_GetOpenedDevicePath (_In_ const CP213x_DEVICE device, LPSTR path );
583 
596 _Check_return_
597 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
598 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
599 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
600 CP213x_GetOpenedVidPid(_In_ const CP213x_DEVICE device, _Out_writes_bytes_opt_(2) WORD* vid, _Out_writes_bytes_opt_(2) WORD* pid);
601 
612 _Check_return_
613 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
614 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
615 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
616 CP213x_Close (_In_ const CP213x_DEVICE hDevice );
617 
628 SLAB_USB_SPI_API BOOL WINAPI
629 CP213x_IsOpened (_In_ const CP213x_DEVICE hDevice);
630 
641 _Check_return_
642 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
643 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
644 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
645 CP213x_Reset (_In_ const CP213x_DEVICE hDevice );
646 
659 _Check_return_
660 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
661 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
662 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
663 CP213x_GetDeviceVersion (_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_opt_(1) BYTE* majorVersion, _Out_writes_bytes_opt_(1) BYTE* minorVersion );
664 
676 _Check_return_
677 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
678 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
679 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
680 CP213x_GetDeviceDescriptor (_In_ const CP213x_DEVICE hDevice,
681  PDEVICE_DESCRIPTOR pDescriptor );
682 
695 _Check_return_
696 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
697 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
698 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
699 CP213x_GetStringDescriptor (_In_ const CP213x_DEVICE hDevice,
700  BYTE index,
701  BYTE stringDescriptor[STRING_DESCRIPTOR_SIZE] );
702 
719 _Check_return_
720 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
721 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
722 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
723 CP213x_GetUsbConfig (_In_ const CP213x_DEVICE hDevice,
724  _Out_writes_bytes_opt_(2) WORD* vid,
725  _Out_writes_bytes_opt_(2) WORD* pid,
726  _Out_writes_bytes_opt_(1) BYTE* pMaxPower,
727  _Out_writes_bytes_opt_(1) BYTE* pPowerMode,
728  _Out_writes_bytes_opt_(2) WORD* releaseVersion,
729  _Out_writes_bytes_opt_(1) BYTE* transferPriority );
730 
750 _Check_return_
751 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
752 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
753 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
754 CP213x_SetUsbConfig (_In_ const CP213x_DEVICE hDevice,
755  _In_ const WORD vid,
756  _In_ const WORD pid,
757  _In_ const BYTE MaxPower,
758  _In_ const BYTE PowerMode,
759  _In_ const WORD releaseVersion,
760  _In_ const BYTE transferPriority,
761  _In_ const BYTE mask );
762 
777 _Check_return_
778 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
779 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
780 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
781 CP213x_GetManufacturingString (_In_ const CP213x_DEVICE hDevice, LPSTR manufacturingString, _Out_writes_bytes_opt_(1) BYTE* manufacturingStringLen);
782 
797 _Check_return_
798 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
799 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
800 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
801 CP213x_SetManufacturingString (_In_ const CP213x_DEVICE hDevice, LPCSTR manufacturingString, _In_ const BYTE manufacturingStringlen );
802 
817 _Check_return_
818 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
819 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
820 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
821 CP213x_GetProductString(_In_ const CP213x_DEVICE hDevice, LPSTR productString, _Out_writes_bytes_opt_(1) BYTE* productStringLen);
822 
837 _Check_return_
838 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
839 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
840 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
841 CP213x_SetProductString(_In_ const CP213x_DEVICE hDevice, LPCSTR productString, _In_ const BYTE productStringlen);
842 
857 _Check_return_
858 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
859 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
860 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
861 CP213x_GetSerialString (_In_ const CP213x_DEVICE hDevice, LPSTR serialString, _Out_writes_bytes_opt_(1) BYTE* serialStringlen);
862 
877 _Check_return_
878 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
879 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
880 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
881 CP213x_SetSerialString (_In_ const CP213x_DEVICE hDevice, LPCSTR serialString, _In_ const BYTE serialStringlen );
882 
896 _Check_return_
897 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
898 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
899 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
900 CP213x_GetPinConfig (_In_ const CP213x_DEVICE hDevice, BYTE pinConfig[SIZE_PIN_CONFIG] );
901 
902 
916 _Check_return_
917 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
918 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
919 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
920 CP213x_SetPinConfig (_In_ const CP213x_DEVICE hDevice, BYTE pinConfig[SIZE_PIN_CONFIG] );
921 
935 _Check_return_
936 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
937 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
938 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
939 CP213x_GetLock(_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_opt_(2) WORD* lockValue);
940 
954 _Check_return_
955 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
956 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
957 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
958 CP213x_SetLock(_In_ const CP213x_DEVICE hDevice, _In_ const WORD lockValue);
959 
971 _Check_return_
972 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
973 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
974 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
975 CP213x_ReadProm (_In_ const CP213x_DEVICE hDevice, BYTE pReadBuf[] );
976 
988 _Check_return_
989 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
990 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
991 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
992 CP213x_WriteProm (_In_ const CP213x_DEVICE hDevice, BYTE pWriteBuf[] );
994 
995 //
996 // CP2130 SPI Configuration and Transfer Operations
997 //
1000 
1012 _Check_return_
1013 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1014 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1015 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1016 CP213x_GetSpiControlBytes (_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_(CP213x_NUM_GPIO) BYTE controlBytes[CP213x_NUM_GPIO] );
1017 
1030 _Check_return_
1031 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1032 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1033 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1034 CP213x_SetSpiControlByte (_In_ const CP213x_DEVICE hDevice, _In_ const BYTE channel, _In_ const BYTE controlByte );
1035 
1051 _Check_return_
1052 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1053 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1054 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1055 CP213x_GetSpiDelay (_In_ const CP213x_DEVICE hDevice,
1056  _In_ const BYTE channel,
1057  BYTE* delayMode,
1058  WORD* interByteDelay,
1059  WORD* postAssertDelay,
1060  WORD* preDeassertDelay );
1061 
1077 _Check_return_
1078 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1079 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1080 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1081 CP213x_SetSpiDelay (_In_ const CP213x_DEVICE hDevice,
1082  _In_ const BYTE channel,
1083  _In_ const BYTE delayMode,
1084  _In_ const WORD interByteDelay,
1085  _In_ const WORD postAssertDelay,
1086  _In_ const WORD preDeassertDelay );
1087 
1100 _Check_return_
1101 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1102 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1103 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1104 CP213x_GetChipSelect (_In_ const CP213x_DEVICE hDevice,
1105  WORD* channelCsEnable,
1106  WORD* pinCsEnable );
1107 
1120 _Check_return_
1121 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1122 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1123 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1124 CP213x_SetChipSelect (_In_ const CP213x_DEVICE hDevice, _In_ const BYTE channel, _In_ const BYTE mode);
1125 
1141 _Check_return_
1142 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1143 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1144 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1145 CP213x_TransferWrite (_In_ const CP213x_DEVICE hDevice,
1146  BYTE pWriteBuf[],
1147  _In_ const DWORD length,
1148  _In_ const BOOL releaseBusAfterTransfer,
1149  _In_ const DWORD timeoutMs,
1150  DWORD * pBytesActuallyWritten);
1151 
1164 
1169 _Check_return_
1170 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1171 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1172 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1173 CP213x_TransferWriteRead (_In_ const CP213x_DEVICE hDevice,
1174  BYTE pWriteBuf[],
1175  BYTE pReadBuf[],
1176  _In_ const DWORD length,
1177  _In_ const BOOL releaseBusAfterTransfer,
1178  _In_ const DWORD timeoutMs,
1179  DWORD* pBytesActuallyTransferred );
1180 
1203 _Check_return_
1204 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1205 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1206 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1207 CP213x_TransferReadAsync (_In_ const CP213x_DEVICE hDevice,
1208  DWORD totalSize,
1209  DWORD blockSize,
1210  BOOL releaseBusAfterTransfer );
1211 
1227 _Check_return_
1228 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1229 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1230 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1231 CP213x_TransferReadSync (_In_ const CP213x_DEVICE hDevice,
1232  BYTE pReadBuf[],
1233  DWORD length,
1234  BOOL releaseBusAfterTransfer,
1235  DWORD timeoutMs,
1236  DWORD* pBytesActuallyRead );
1237 
1251 _Check_return_
1252 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1253 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1254 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1255 CP213x_TransferReadRtrAsync (_In_ const CP213x_DEVICE hDevice,
1256  DWORD totalSize,
1257  DWORD blockSize,
1258  BOOL releaseBusAfterTransfer );
1259 
1276 _Check_return_
1277 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1278 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1279 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1280 CP213x_TransferReadRtrSync (_In_ const CP213x_DEVICE hDevice,
1281  BYTE pReadBuf[],
1282  DWORD totalSize,
1283  DWORD blockSize,
1284  BOOL releaseBusAfterTransfer,
1285  DWORD timeoutMs,
1286  DWORD* pBytesActuallyRead );
1287 
1299 _Check_return_
1300 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1301 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1302 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1303 CP213x_GetRtrState (_In_ const CP213x_DEVICE hDevice, BYTE* isStopped );
1304 
1316 _Check_return_
1317 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1318 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1319 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1320 CP213x_SetRtrStop (_In_ const CP213x_DEVICE hDevice, BYTE stopRtr );
1321 
1337 _Check_return_
1338 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1339 _Success_(USB_SPI_ERRCODE_SUCCESS)
1340 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1341 CP213x_ReadPoll (_In_ const CP213x_DEVICE hDevice,
1342  BYTE pReadBuf[],
1343  DWORD maxLength,
1344  DWORD* pBytesActuallyRead );
1345 
1358 _Check_return_
1359 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1360 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1361 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1362 CP213x_ReadAbort (_In_ const CP213x_DEVICE hDevice );
1363 
1374 _Check_return_
1375 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1376 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1377 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1378 CP213x_AbortInputPipe (_In_ const CP213x_DEVICE hDevice );
1379 
1390 _Check_return_
1391 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1392 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1393 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1394 CP213x_AbortOutputPipe (_In_ const CP213x_DEVICE hDevice );
1395 
1406 _Check_return_
1407 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1408 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1409 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1410 CP213x_FlushInputPipe (_In_ const CP213x_DEVICE hDevice );
1411 
1422 _Check_return_
1423 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1424 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1425 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1426 CP213x_FlushOutputPipe (_In_ const CP213x_DEVICE hDevice );
1427 
1439 _Check_return_
1440 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1441 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1442 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1443 CP213x_GetFifoFullThreshold (_In_ const CP213x_DEVICE hDevice, BYTE* pFifoFullThreshold );
1444 
1456 _Check_return_
1457 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1458 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1459 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1460 CP213x_SetFifoFullThreshold (_In_ const CP213x_DEVICE hDevice, _In_ const BYTE fifoFullThreshold );
1461 
1463 
1464 //
1465 // CP2130 GPIO and Auxiliary-Function Pins
1466 //
1469 
1483 _Check_return_
1484 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1485 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1486 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1487 CP213x_GetGpioModeAndLevel(_In_ const CP213x_DEVICE hDevice, _In_ _In_range_(0, CP213x_NUM_GPIO - 1) const BYTE channel, _Out_writes_bytes_opt_(1) BYTE* mode, _Out_writes_bytes_opt_(1) BYTE* level);
1488 
1502 _Check_return_
1503 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1504 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1505 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1506 CP213x_SetGpioModeAndLevel (_In_ const CP213x_DEVICE hDevice, _In_ _In_range_(0, CP213x_NUM_GPIO-1) const BYTE channel, const BYTE mode, const BYTE level );
1507 
1519 _Check_return_
1520 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1521 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1522 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1523 CP213x_GetGpioValues (_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_opt_(2) WORD* gpioValues );
1524 
1537 _Check_return_
1538 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1539 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1540 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1541 CP213x_SetGpioValues (_In_ const CP213x_DEVICE hDevice, _In_ const WORD mask, _In_ const WORD gpioValues );
1542 
1555 _Check_return_
1556 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1557 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1558 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1559 CP213x_GetEventCounter (_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_opt_(1) BYTE* mode, _Out_writes_bytes_opt_(2) WORD* eventCount );
1560 
1573 _Check_return_
1574 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1575 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1576 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1577 CP213x_SetEventCounter (_In_ const CP213x_DEVICE hDevice, _In_ const BYTE mode, _In_ const WORD eventCount );
1578 
1590 _Check_return_
1591 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1592 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1593 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1594 CP213x_GetClockDivider (_In_ const CP213x_DEVICE hDevice, _Out_writes_bytes_opt_(1) BYTE* clockDivider );
1595 
1607 _Check_return_
1608 _Ret_range_(USB_SPI_ERRCODE_SUCCESS, MAXLONG)
1609 _Success_(return == USB_SPI_ERRCODE_SUCCESS)
1610 SLAB_USB_SPI_API USB_SPI_STATUS WINAPI
1611 CP213x_SetClockDivider (_In_ const CP213x_DEVICE hDevice, _In_ const BYTE clockDivider );
1612 
1614 
1615 #ifdef __cplusplus
1616 }
1617 #endif // __cplusplus
1618 
1620 
1621 #endif // HOST_LIB_SLABUSBSPI_INCLUDE_SLAB_USB_SPI_H_INCLUDED_9QK7BKA9FX
1622 // End of file
USB_SPI_ERRCODE_INVALID_ENUM_VALUE
Invalid enumeration value.
Definition: SLAB_USB_SPI.h:182
CP213x_GetSerialString
USB_SPI_STATUS CP213x_GetSerialString(const CP213x_DEVICE hDevice, LPSTR serialString, BYTE *serialStringlen)
Get the USB device Serial Number string.
SUBCMD_WRITEREAD
#define SUBCMD_WRITEREAD
Sub-command write read.
Definition: SLAB_USB_SPI.h:123
USB_SPI_ERRCODE_PIPE_INIT_FAIL
USB SPI error code pipe init fail.
Definition: SLAB_USB_SPI.h:217
STRING_DESCRIPTOR_SIZE
#define STRING_DESCRIPTOR_SIZE
String descriptor size.
Definition: SLAB_USB_SPI.h:70
USB_SPI_ERRCODE_READ_THREAD_CREATE_FAILURE
USB SPI error code read thread create failure.
Definition: SLAB_USB_SPI.h:225
USB_SPI_ERRCODE_READ_THREAD_START_FAILURE
USB SPI error code read thread start failure.
Definition: SLAB_USB_SPI.h:227
PUSB_SPI_STATUS
enum _USB_SPI_STATUS * PUSB_SPI_STATUS
API Status return codes pointer.
USB_SPI_ERRCODE_INVALID_TRANSFER_SIZE
USB SPI error code invalid transfer size.
Definition: SLAB_USB_SPI.h:215
CP213x_SetEventCounter
USB_SPI_STATUS CP213x_SetEventCounter(const CP213x_DEVICE hDevice, const BYTE mode, const WORD eventCount)
what it does in brief
USB_SPI_ERRCODE_PIPE_READ_FAIL
USB SPI error code pipe read fail.
Definition: SLAB_USB_SPI.h:220
CP213x_SetSpiControlByte
USB_SPI_STATUS CP213x_SetSpiControlByte(const CP213x_DEVICE hDevice, const BYTE channel, const BYTE controlByte)
what it does in brief
CP213x_TransferWrite
USB_SPI_STATUS CP213x_TransferWrite(const CP213x_DEVICE hDevice, BYTE pWriteBuf[], const DWORD length, const BOOL releaseBusAfterTransfer, const DWORD timeoutMs, DWORD *pBytesActuallyWritten)
what it does in brief
CP213x_ReadAbort
USB_SPI_STATUS CP213x_ReadAbort(const CP213x_DEVICE hDevice)
Abort an asynchronous Read or ReadRTR operation.
USB_SPI_ERRCODE_ALLOC_FAILURE
Allocation error.
Definition: SLAB_USB_SPI.h:181
CP213x_GetProductString
USB_SPI_STATUS CP213x_GetProductString(const CP213x_DEVICE hDevice, LPSTR productString, BYTE *productStringLen)
Get the USB device Product string.
CP213x_GetClockDivider
USB_SPI_STATUS CP213x_GetClockDivider(const CP213x_DEVICE hDevice, BYTE *clockDivider)
what it does in brief
CP213x_GetDevicePath
USB_SPI_STATUS CP213x_GetDevicePath(const DWORD deviceIndex, LPSTR path)
what it does in brief
CP213x_GetOpenedDevicePath
USB_SPI_STATUS CP213x_GetOpenedDevicePath(const CP213x_DEVICE device, LPSTR path)
what it does in brief
CP213x_AbortInputPipe
USB_SPI_STATUS CP213x_AbortInputPipe(const CP213x_DEVICE hDevice)
what it does in brief
CP213x_DEVICE
void * CP213x_DEVICE
CP213X_DEVICE opaque object.
Definition: SLAB_USB_SPI.h:58
USB_SPI_ERRCODE_NULL_POINTER
Null pointer.
Definition: SLAB_USB_SPI.h:183
CP213x_AbortOutputPipe
USB_SPI_STATUS CP213x_AbortOutputPipe(const CP213x_DEVICE hDevice)
what it does in brief
CP213x_GetDeviceVersion
USB_SPI_STATUS CP213x_GetDeviceVersion(const CP213x_DEVICE hDevice, BYTE *majorVersion, BYTE *minorVersion)
what it does in brief
CP213x_GetLibraryVersion
USB_SPI_STATUS CP213x_GetLibraryVersion(BYTE *major, BYTE *minor, BOOL *release)
what it does in brief
CP213x_SetGpioModeAndLevel
USB_SPI_STATUS CP213x_SetGpioModeAndLevel(const CP213x_DEVICE hDevice, const BYTE channel, const BYTE mode, const BYTE level)
what it does in brief
CP213x_Reset
USB_SPI_STATUS CP213x_Reset(const CP213x_DEVICE hDevice)
what it does in brief
SILABS_STATUS_SUCCESS
no error
Definition: silabs_defs.h:262
CP213x_TransferReadAsync
USB_SPI_STATUS CP213x_TransferReadAsync(const CP213x_DEVICE hDevice, DWORD totalSize, DWORD blockSize, BOOL releaseBusAfterTransfer)
Perform SPI Read (asynchronous)
USB_SPI_ERRCODE_PIPE_WRITE_FAIL
USB SPI error code pipe write fail.
Definition: SLAB_USB_SPI.h:219
CP213x_GetGpioModeAndLevel
USB_SPI_STATUS CP213x_GetGpioModeAndLevel(const CP213x_DEVICE hDevice, const BYTE channel, BYTE *mode, BYTE *level)
what it does in brief
SUBCMD_RTREAD
#define SUBCMD_RTREAD
Sub-command RT read.
Definition: SLAB_USB_SPI.h:124
USB_SPI_ERRCODE_SYSTEM_ERROR
USB SPI error code system error.
Definition: SLAB_USB_SPI.h:231
DEVICE_DESCRIPTOR
Definition: SLAB_USB_SPI.h:320
SLAB_USB_SPI_API
#define SLAB_USB_SPI_API
Silabs USB to SPI API.
Definition: SLAB_USB_SPI.h:36
CP213x_SetSerialString
USB_SPI_STATUS CP213x_SetSerialString(const CP213x_DEVICE hDevice, LPCSTR serialString, const BYTE serialStringlen)
Set the USB device Serial Number string.
PRODUCT_STR
char PRODUCT_STR[62]
Product string.
Definition: SLAB_USB_SPI.h:266
USB_SPI_ERRCODE_CONTROL_TRANSFER_ERROR
USB SPI error code control transfer error.
Definition: SLAB_USB_SPI.h:214
CP213x_GetSpiDelay
USB_SPI_STATUS CP213x_GetSpiDelay(const CP213x_DEVICE hDevice, const BYTE channel, BYTE *delayMode, WORD *interByteDelay, WORD *postAssertDelay, WORD *preDeassertDelay)
what it does in brief
CP213x_GetRtrState
USB_SPI_STATUS CP213x_GetRtrState(const CP213x_DEVICE hDevice, BYTE *isStopped)
what it does in brief
USB_SPI_ERRCODE_USB_DEVICE_NOT_OPENED
The current USB device is not opened.
Definition: SLAB_USB_SPI.h:200
SERIAL_STRLEN
#define SERIAL_STRLEN
Serial string length.
Definition: SLAB_USB_SPI.h:263
CP213x_SetManufacturingString
USB_SPI_STATUS CP213x_SetManufacturingString(const CP213x_DEVICE hDevice, LPCSTR manufacturingString, const BYTE manufacturingStringlen)
Set the USB device Manufacturer string.
CP213x_GetDeviceDescriptor
USB_SPI_STATUS CP213x_GetDeviceDescriptor(const CP213x_DEVICE hDevice, PDEVICE_DESCRIPTOR pDescriptor)
what it does in brief
CP213x_TransferWriteRead
USB_SPI_STATUS CP213x_TransferWriteRead(const CP213x_DEVICE hDevice, BYTE pWriteBuf[], BYTE pReadBuf[], const DWORD length, const BOOL releaseBusAfterTransfer, const DWORD timeoutMs, DWORD *pBytesActuallyTransferred)
what it does in brief
USB_SPI_ERRCODE_DEVICE_RETURNED_TOO_MUCH_DATA
USB SPI error code device returned too much data.
Definition: SLAB_USB_SPI.h:229
CP213x_GetFifoFullThreshold
USB_SPI_STATUS CP213x_GetFifoFullThreshold(const CP213x_DEVICE hDevice, BYTE *pFifoFullThreshold)
what it does in brief
CP213x_SetGuid
USB_SPI_STATUS CP213x_SetGuid(LPGUID guid)
what it does in brief
SERIAL_STR
char SERIAL_STR[30]
Serial string.
Definition: SLAB_USB_SPI.h:267
USB_SPI_ERRCODE_PIPE_ABORT_FAIL
USB SPI error code pipe abort fail.
Definition: SLAB_USB_SPI.h:221
USB_SPI_STATUS
USB_SPI_STATUS
API Status return codes.
Definition: SLAB_USB_SPI.h:178
CP213x_TransferReadRtrSync
USB_SPI_STATUS CP213x_TransferReadRtrSync(const CP213x_DEVICE hDevice, BYTE pReadBuf[], DWORD totalSize, DWORD blockSize, BOOL releaseBusAfterTransfer, DWORD timeoutMs, DWORD *pBytesActuallyRead)
what it does in brief
WINAPI
#define WINAPI
Win API.
Definition: SLAB_USB_SPI.h:37
CP213x_SetLock
USB_SPI_STATUS CP213x_SetLock(const CP213x_DEVICE hDevice, const WORD lockValue)
Set the Lock values.
USB_SPI_ERRCODE_INVALID_GPIO_MODE
Mode != INPUT, OUTPUT_OD, or OUTPUT_PP.
Definition: SLAB_USB_SPI.h:185
BYTE
unsigned char BYTE
Byte definition.
Definition: silabs_defs.h:41
CP213x_SetFifoFullThreshold
USB_SPI_STATUS CP213x_SetFifoFullThreshold(const CP213x_DEVICE hDevice, const BYTE fifoFullThreshold)
what it does in brief
CP213x_GetNumDevices
USB_SPI_STATUS CP213x_GetNumDevices(DWORD *numDevices, DWORD VID, DWORD PID)
what it does in brief
CP213x_GetGpioValues
USB_SPI_STATUS CP213x_GetGpioValues(const CP213x_DEVICE hDevice, WORD *gpioValues)
what it does in brief
MFG_STR
char MFG_STR[62]
Manufacture string.
Definition: SLAB_USB_SPI.h:265
MFG_STRLEN
#define MFG_STRLEN
Manufacture string length.
Definition: SLAB_USB_SPI.h:261
CP213x_ReadPoll
USB_SPI_STATUS CP213x_ReadPoll(const CP213x_DEVICE hDevice, BYTE pReadBuf[], DWORD maxLength, DWORD *pBytesActuallyRead)
Read bytes received during an asynchronous Read or ReadRTR operation.
USB_SPI_ERRCODE_INVALID_PARAMETER
Invalid function parameter.
Definition: SLAB_USB_SPI.h:192
CP213x_Open
USB_SPI_STATUS CP213x_Open(DWORD deviceIndex, CP213x_DEVICE *phDevice, DWORD VID, DWORD PID)
Opens a USB device using a device index and returns a device object pointer which will be used for su...
SUBCMD_WRITE
#define SUBCMD_WRITE
Sub-command write.
Definition: SLAB_USB_SPI.h:122
CP213x_FlushOutputPipe
USB_SPI_STATUS CP213x_FlushOutputPipe(const CP213x_DEVICE hDevice)
what it does in brief
USB_SPI_ERRCODE_HWIF_DEVICE_ERROR
An error occurred while communicating with the device or while retrieving device information.
Definition: SLAB_USB_SPI.h:207
USB_SPI_ERRCODE_DEVICE_NOT_FOUND
The specified USB device could not be found.
Definition: SLAB_USB_SPI.h:199
CP213x_GetStringDescriptor
USB_SPI_STATUS CP213x_GetStringDescriptor(const CP213x_DEVICE hDevice, BYTE index, BYTE stringDescriptor[256])
what it does in brief
CP213x_TransferReadSync
USB_SPI_STATUS CP213x_TransferReadSync(const CP213x_DEVICE hDevice, BYTE pReadBuf[], DWORD length, BOOL releaseBusAfterTransfer, DWORD timeoutMs, DWORD *pBytesActuallyRead)
what it does in brief
CP213x_GetLock
USB_SPI_STATUS CP213x_GetLock(const CP213x_DEVICE hDevice, WORD *lockValue)
Get the Lock values.
CP213x_IsOpened
BOOL CP213x_IsOpened(const CP213x_DEVICE hDevice)
what it does in brief
CP213x_SetPinConfig
USB_SPI_STATUS CP213x_SetPinConfig(const CP213x_DEVICE hDevice, BYTE pinConfig[20])
Set the USB device Pin Configuration info.
USB_SPI_ERRCODE_SUCCESS
The function returned successfully.
Definition: SLAB_USB_SPI.h:180
USB_SPI_ERRCODE_PIPE_QUERY_FAIL
USB SPI error code pipe query fail.
Definition: SLAB_USB_SPI.h:218
CP213x_GetUsbConfig
USB_SPI_STATUS CP213x_GetUsbConfig(const CP213x_DEVICE hDevice, WORD *vid, WORD *pid, BYTE *pMaxPower, BYTE *pPowerMode, WORD *releaseVersion, BYTE *transferPriority)
Get the USB Device Configuration info.
CP213x_GetChipSelect
USB_SPI_STATUS CP213x_GetChipSelect(const CP213x_DEVICE hDevice, WORD *channelCsEnable, WORD *pinCsEnable)
what it does in brief
CP213x_Close
USB_SPI_STATUS CP213x_Close(const CP213x_DEVICE hDevice)
what it does in brief
CP213x_SetChipSelect
USB_SPI_STATUS CP213x_SetChipSelect(const CP213x_DEVICE hDevice, const BYTE channel, const BYTE mode)
what it does in brief
CP213x_GetManufacturingString
USB_SPI_STATUS CP213x_GetManufacturingString(const CP213x_DEVICE hDevice, LPSTR manufacturingString, BYTE *manufacturingStringLen)
Get the USB device Manufacturer string.
USB_SPI_ERRCODE_PIPE_INVALID_ID
USB SPI error code pipe invalid id.
Definition: SLAB_USB_SPI.h:223
SIZE_PIN_CONFIG
#define SIZE_PIN_CONFIG
Config pin size.
Definition: SLAB_USB_SPI.h:71
PRODUCT_STRLEN
#define PRODUCT_STRLEN
Product string length.
Definition: SLAB_USB_SPI.h:262
_SPI_CMD
SPI Command Word. Alias of this struct is SPI_CMD.
SUBCMD_READ
#define SUBCMD_READ
Sub-command read.
Definition: SLAB_USB_SPI.h:121
CP213x_SetGpioValues
USB_SPI_STATUS CP213x_SetGpioValues(const CP213x_DEVICE hDevice, const WORD mask, const WORD gpioValues)
what it does in brief
USB_SPI_ERRCODE_INVALID_HANDLE
The handle is invalid.
Definition: SLAB_USB_SPI.h:201
USB_SPI_ERRCODE_INVALID_CHANNEL_INDEX
Channel index is not in range.
Definition: SLAB_USB_SPI.h:184
CP213x_GetOpenedVidPid
USB_SPI_STATUS CP213x_GetOpenedVidPid(const CP213x_DEVICE device, WORD *vid, WORD *pid)
what it does in brief
CP213x_NUM_GPIO
#define CP213x_NUM_GPIO
Number of GPIO/CS pins.
Definition: SLAB_USB_SPI.h:78
CP213x_FlushInputPipe
USB_SPI_STATUS CP213x_FlushInputPipe(const CP213x_DEVICE hDevice)
what it does in brief
USB_SPI_ERRCODE_INVALID_DEVICE_OBJECT
The specified device object pointer is invalid.
Definition: SLAB_USB_SPI.h:194
MAX_PATH
#define MAX_PATH
Max string path length.
Definition: SLAB_USB_SPI.h:47
CP213x_TransferReadRtrAsync
USB_SPI_STATUS CP213x_TransferReadRtrAsync(const CP213x_DEVICE hDevice, DWORD totalSize, DWORD blockSize, BOOL releaseBusAfterTransfer)
what it does in brief
CP213x_SetUsbConfig
USB_SPI_STATUS CP213x_SetUsbConfig(const CP213x_DEVICE hDevice, const WORD vid, const WORD pid, const BYTE MaxPower, const BYTE PowerMode, const WORD releaseVersion, const BYTE transferPriority, const BYTE mask)
Set the USB device Configuration info.
CP213x_GetGuid
USB_SPI_STATUS CP213x_GetGuid(LPGUID guid)
what it does in brief
CP213x_SetClockDivider
USB_SPI_STATUS CP213x_SetClockDivider(const CP213x_DEVICE hDevice, const BYTE clockDivider)
what it does in brief
CP213x_SetSpiDelay
USB_SPI_STATUS CP213x_SetSpiDelay(const CP213x_DEVICE hDevice, const BYTE channel, const BYTE delayMode, const WORD interByteDelay, const WORD postAssertDelay, const WORD preDeassertDelay)
what it does in brief
USB_SPI_ERRCODE_HWIF_TRANSFER_TIMEOUT
A control transfer operation timed out.
Definition: SLAB_USB_SPI.h:210
CP213x_GetSpiControlBytes
USB_SPI_STATUS CP213x_GetSpiControlBytes(const CP213x_DEVICE hDevice, BYTE controlBytes[11])
what it does in brief
CP213x_GetEventCounter
USB_SPI_STATUS CP213x_GetEventCounter(const CP213x_DEVICE hDevice, BYTE *mode, WORD *eventCount)
what it does in brief
CP213x_ReadProm
USB_SPI_STATUS CP213x_ReadProm(const CP213x_DEVICE hDevice, BYTE pReadBuf[])
what it does in brief
USB_SPI_ERRCODE_READ_THREAD_NOT_RUNNING
USB SPI error code read thread not running.
Definition: SLAB_USB_SPI.h:226
USB_SPI_ERRCODE_UNKNOWN_ERROR
Unknown/unspecified error. TODO: No, not all-F's, how about 0xFF?
Definition: SLAB_USB_SPI.h:187
CP213x_WriteProm
USB_SPI_STATUS CP213x_WriteProm(const CP213x_DEVICE hDevice, BYTE pWriteBuf[])
what it does in brief
CP213x_SetRtrStop
USB_SPI_STATUS CP213x_SetRtrStop(const CP213x_DEVICE hDevice, BYTE stopRtr)
what it does in brief
SPI_CMD
Definition: SLAB_USB_SPI.h:341
CP213x_GetVidPid
USB_SPI_STATUS CP213x_GetVidPid(const DWORD deviceIndex, WORD *vid, WORD *pid)
what it does in brief
CP213x_GetPinConfig
USB_SPI_STATUS CP213x_GetPinConfig(const CP213x_DEVICE hDevice, BYTE pinConfig[20])
Get the USB device Pin Configuration info.
CP213x_SetProductString
USB_SPI_STATUS CP213x_SetProductString(const CP213x_DEVICE hDevice, LPCSTR productString, const BYTE productStringlen)
Set the USB device Product string.
SET_STATUS
SET_STATUS
Set status return.
Definition: SLAB_USB_SPI.h:274
USB_SPI_ERRCODE_PIPE_FLUSH_FAIL
USB SPI error code pipe flush fail.
Definition: SLAB_USB_SPI.h:222