libftdi1 1.4
ftdi.cpp
Go to the documentation of this file.
1/***************************************************************************
2 ftdi.cpp - C++ wraper for libftdi
3 -------------------
4 begin : Mon Oct 13 2008
5 copyright : (C) 2008-2017 by Marek Vavruša / libftdi developers
6 email : opensource@intra2net.com and marek@vavrusa.com
7 ***************************************************************************/
8/*
9Copyright (C) 2008-2017 by Marek Vavruša / libftdi developers
10
11The software in this package is distributed under the GNU General
12Public License version 2 (with a special exception described below).
13
14A copy of GNU General Public License (GPL) is included in this distribution,
15in the file COPYING.GPL.
16
17As a special exception, if other files instantiate templates or use macros
18or inline functions from this file, or you compile this file and link it
19with other works to produce a work based on this file, this file
20does not by itself cause the resulting work to be covered
21by the GNU General Public License.
22
23However the source code for this file must still be made available
24in accordance with section (3) of the GNU General Public License.
25
26This exception does not invalidate any other reasons why a work based
27on this file might be covered by the GNU General Public License.
28*/
29#include <libusb.h>
30#include "ftdi.hpp"
31#include "ftdi_i.h"
32#include "ftdi.h"
33
34namespace Ftdi
35{
36
38{
39public:
41 : open(false), ftdi(0), dev(0)
42 {
43 ftdi = ftdi_new();
44 }
45
47 {
48 if (open)
50
52 }
53
54 bool open;
55
57 struct libusb_device* dev;
58
59 std::string vendor;
60 std::string description;
61 std::string serial;
62};
63
67 : d( new Private() )
68{
69}
70
74{
75}
76
78{
79 return d->open;
80}
81
82int Context::open(int vendor, int product)
83{
84 // Open device
85 int ret = ftdi_usb_open(d->ftdi, vendor, product);
86
87 if (ret < 0)
88 return ret;
89
90 return get_strings_and_reopen(false,false,false);
91}
92
93int Context::open(int vendor, int product, const std::string& description, const std::string& serial, unsigned int index)
94{
95 // translate empty strings to NULL
96 // -> do not use them to find the device (vs. require an empty string to be set in the EEPROM)
97 const char* c_description=NULL;
98 const char* c_serial=NULL;
99 if (!description.empty())
100 c_description=description.c_str();
101 if (!serial.empty())
102 c_serial=serial.c_str();
103
104 int ret = ftdi_usb_open_desc_index(d->ftdi, vendor, product, c_description, c_serial, index);
105
106 if (ret < 0)
107 return ret;
108
109 return get_strings_and_reopen(false,!description.empty(),!serial.empty());
110}
111
112int Context::open(const std::string& description)
113{
114 int ret = ftdi_usb_open_string(d->ftdi, description.c_str());
115
116 if (ret < 0)
117 return ret;
118
119 return get_strings_and_reopen(false,true,false);
120}
121
122int Context::open(struct libusb_device *dev)
123{
124 if (dev != 0)
125 d->dev = dev;
126
127 if (d->dev == 0)
128 return -1;
129
130 return get_strings_and_reopen();
131}
132
134{
135 d->open = false;
136 d->dev = 0;
137 return ftdi_usb_close(d->ftdi);
138}
139
141{
142 return ftdi_usb_reset(d->ftdi);
143}
144
145int Context::flush(int mask)
146{
147 int ret;
148
149 switch (mask & (Input | Output)) {
150 case Input:
151 ret = ftdi_usb_purge_rx_buffer(d->ftdi);
152 break;
153
154 case Output:
155 ret = ftdi_usb_purge_tx_buffer(d->ftdi);
156 break;
157
158 case Input | Output:
159 ret = ftdi_usb_purge_buffers(d->ftdi);
160 break;
161
162 default:
163 // Emulate behavior of previous version.
164 ret = 1;
165 break;
166 }
167
168 return ret;
169}
170
172{
173 return ftdi_set_interface(d->ftdi, interface);
174}
175
176void Context::set_usb_device(struct libusb_device_handle *dev)
177{
178 ftdi_set_usbdev(d->ftdi, dev);
179 d->dev = libusb_get_device(dev);
180}
181
182int Context::set_baud_rate(int baudrate)
183{
184 return ftdi_set_baudrate(d->ftdi, baudrate);
185}
186
188{
189 return ftdi_set_line_property(d->ftdi, bits, sbit, parity);
190}
191
193{
194 return ftdi_set_line_property2(d->ftdi, bits, sbit, parity, break_type);
195}
196
198{
199 return d->ftdi->usb_read_timeout;
200}
201
202void Context::set_usb_read_timeout(int usb_read_timeout)
203{
204 d->ftdi->usb_read_timeout = usb_read_timeout;
205}
206
208{
209 return d->ftdi->usb_write_timeout;
210}
211
212void Context::set_usb_write_timeout(int usb_write_timeout)
213{
214 d->ftdi->usb_write_timeout = usb_write_timeout;
215}
216
217int Context::read(unsigned char *buf, int size)
218{
219 return ftdi_read_data(d->ftdi, buf, size);
220}
221
222int Context::set_read_chunk_size(unsigned int chunksize)
223{
224 return ftdi_read_data_set_chunksize(d->ftdi, chunksize);
225}
226
228{
229 unsigned chunk = -1;
230 if (ftdi_read_data_get_chunksize(d->ftdi, &chunk) < 0)
231 return -1;
232
233 return chunk;
234}
235
236int Context::write(const unsigned char *buf, int size)
237{
238 return ftdi_write_data(d->ftdi, buf, size);
239}
240
241int Context::set_write_chunk_size(unsigned int chunksize)
242{
243 return ftdi_write_data_set_chunksize(d->ftdi, chunksize);
244}
245
247{
248 unsigned chunk = -1;
249 if (ftdi_write_data_get_chunksize(d->ftdi, &chunk) < 0)
250 return -1;
251
252 return chunk;
253}
254
256{
257 return ftdi_setflowctrl(d->ftdi, flowctrl);
258}
259
261{
262 int dtr = 0, rts = 0;
263
264 if (mask & Dtr)
265 dtr = 1;
266 if (mask & Rts)
267 rts = 1;
268
269 return ftdi_setdtr_rts(d->ftdi, dtr, rts);
270}
271
272int Context::set_dtr(bool state)
273{
274 return ftdi_setdtr(d->ftdi, state);
275}
276
277int Context::set_rts(bool state)
278{
279 return ftdi_setrts(d->ftdi, state);
280}
281
282int Context::set_latency(unsigned char latency)
283{
284 return ftdi_set_latency_timer(d->ftdi, latency);
285}
286
288{
289 unsigned char latency = 0;
291 return latency;
292}
293
295{
296 unsigned short status = 0;
297 ftdi_poll_modem_status(d->ftdi, &status);
298 return status;
299}
300
301int Context::set_event_char(unsigned char eventch, unsigned char enable)
302{
303 return ftdi_set_event_char(d->ftdi, eventch, enable);
304}
305
306int Context::set_error_char(unsigned char errorch, unsigned char enable)
307{
308 return ftdi_set_error_char(d->ftdi, errorch, enable);
309}
310
311int Context::set_bitmode(unsigned char bitmask, unsigned char mode)
312{
313 return ftdi_set_bitmode(d->ftdi, bitmask, mode);
314}
315
316int Context::set_bitmode(unsigned char bitmask, enum ftdi_mpsse_mode mode)
317{
318 return ftdi_set_bitmode(d->ftdi, bitmask, mode);
319}
320
322{
323 return ftdi_disable_bitbang(d->ftdi);
324}
325
326int Context::read_pins(unsigned char *pins)
327{
328 return ftdi_read_pins(d->ftdi, pins);
329}
330
332{
333 return ftdi_get_error_string(d->ftdi);
334}
335
336int Context::get_strings(bool vendor, bool description, bool serial)
337{
338 // Prepare buffers
339 char ivendor[512], idesc[512], iserial[512];
340
341 int ret = ftdi_usb_get_strings(d->ftdi, d->dev, vendor?ivendor:NULL, 512, description?idesc:NULL, 512, serial?iserial:NULL, 512);
342
343 if (ret < 0)
344 return -1;
345
346 d->vendor = ivendor;
347 d->description = idesc;
348 d->serial = iserial;
349
350 return 1;
351}
352
353int Context::get_strings_and_reopen(bool vendor, bool description, bool serial)
354{
355 int ret = 0;
356
357 if(vendor || description || serial)
358 {
359 if (d->dev == 0)
360 {
361 d->dev = libusb_get_device(d->ftdi->usb_dev);
362 }
363
364 // Get device strings (closes device)
366 if (ret < 0)
367 {
368 d->open = 0;
369 return ret;
370 }
371
372 // Reattach device
373 ret = ftdi_usb_open_dev(d->ftdi, d->dev);
374 d->open = (ret >= 0);
375 }
376
377 return ret;
378}
379
382const std::string& Context::vendor()
383{
384 if(d->vendor.empty())
385 get_strings_and_reopen(true,false,false);
386 return d->vendor;
387}
388
391const std::string& Context::description()
392{
393 if(d->description.empty())
394 get_strings_and_reopen(false,true,false);
395 return d->description;
396}
397
400const std::string& Context::serial()
401{
402 if(d->serial.empty())
403 get_strings_and_reopen(false,false,true);
404 return d->serial;
405}
406
408{
409 ftdi_free(d->ftdi);
410 d->ftdi = context;
411}
412
413void Context::set_usb_device(struct libusb_device *dev)
414{
415 d->dev = dev;
416}
417
419{
420 return d->ftdi;
421}
422
424{
425public:
427 : context(0)
428 {}
429
432};
433
435 : d ( new Private() )
436{
437 d->context = parent->context();
438}
439
441{
442}
443
444int Eeprom::init_defaults(char* manufacturer, char *product, char * serial)
445{
446 return ftdi_eeprom_initdefaults(d->context, manufacturer, product, serial);
447}
448
449int Eeprom::chip_id(unsigned int *chipid)
450{
451 return ftdi_read_chipid(d->context, chipid);
452}
453
454int Eeprom::build(unsigned char *output)
455{
456 return ftdi_eeprom_build(d->context);
457}
458
459int Eeprom::read(unsigned char *eeprom)
460{
461 return ftdi_read_eeprom(d->context);
462}
463
464int Eeprom::write(unsigned char *eeprom)
465{
466 return ftdi_write_eeprom(d->context);
467}
468
469int Eeprom::read_location(int eeprom_addr, unsigned short *eeprom_val)
470{
471 return ftdi_read_eeprom_location(d->context, eeprom_addr, eeprom_val);
472}
473
474int Eeprom::write_location(int eeprom_addr, unsigned short eeprom_val)
475{
476 return ftdi_write_eeprom_location(d->context, eeprom_addr, eeprom_val);
477}
478
480{
481 return ftdi_erase_eeprom(d->context);
482}
483
485{
486public:
487 Private(struct ftdi_device_list* _devlist)
488 : devlist(_devlist)
489 {}
490
492 {
493 if(devlist)
495 }
496
497 std::list<Context> list;
499};
500
502 : d( new Private(devlist) )
503{
504 if (devlist != 0)
505 {
506 // Iterate list
507 for (; devlist != 0; devlist = devlist->next)
508 {
509 Context c;
510 c.set_usb_device(devlist->dev);
511 c.get_strings();
512 d->list.push_back(c);
513 }
514 }
515}
516
518{
519}
520
526{
527 return d->list.begin();
528}
529
535{
536 return d->list.end();
537}
538
544{
545 return d->list.begin();
546}
547
553{
554 return d->list.end();
555}
556
562{
563 return d->list.rbegin();
564}
565
571{
572 return d->list.rend();
573}
574
580{
581 return d->list.rbegin();
582}
583
589{
590 return d->list.rend();
591
592}
593
598List::ListType::size_type List::size() const
599{
600 return d->list.size();
601}
602
607bool List::empty() const
608{
609 return d->list.empty();
610}
611
618{
619 ListType().swap(d->list);
620
621 // Free device list
622 if (d->devlist)
623 {
624 ftdi_list_free(&d->devlist);
625 d->devlist = 0;
626 }
627}
628
633void List::push_back(const Context& element)
634{
635 d->list.push_back(element);
636}
637
642void List::push_front(const Context& element)
643{
644 d->list.push_front(element);
645}
646
653{
654 return d->list.erase(pos);
655}
656
664{
665 return d->list.erase(beg, end);
666}
667
668List* List::find_all(Context &context, int vendor, int product)
669{
670 struct ftdi_device_list* dlist = 0;
671 ftdi_usb_find_all(context.context(), &dlist, vendor, product);
672 return new List(dlist);
673}
674
675}
std::string vendor
Definition: ftdi.cpp:59
std::string description
Definition: ftdi.cpp:60
std::string serial
Definition: ftdi.cpp:61
struct ftdi_context * ftdi
Definition: ftdi.cpp:56
struct libusb_device * dev
Definition: ftdi.cpp:57
FTDI device context. Represents single FTDI device context.
Definition: ftdi.hpp:48
const char * error_string()
Definition: ftdi.cpp:331
Context()
Constructor.
Definition: ftdi.cpp:66
int set_flow_control(int flowctrl)
Definition: ftdi.cpp:255
int set_baud_rate(int baudrate)
Definition: ftdi.cpp:182
const std::string & description()
Device strings properties.
Definition: ftdi.cpp:391
int read(unsigned char *buf, int size)
Definition: ftdi.cpp:217
int flush(int mask=Input|Output)
Definition: ftdi.cpp:145
bool is_open()
Definition: ftdi.cpp:77
int reset()
Definition: ftdi.cpp:140
const std::string & serial()
Device strings properties.
Definition: ftdi.cpp:400
void set_usb_device(struct libusb_device_handle *dev)
Definition: ftdi.cpp:176
void set_usb_write_timeout(int usb_write_timeout)
Definition: ftdi.cpp:212
int get_usb_read_timeout() const
Definition: ftdi.cpp:197
int read_chunk_size()
Definition: ftdi.cpp:227
int set_write_chunk_size(unsigned int chunksize)
Definition: ftdi.cpp:241
int set_error_char(unsigned char errorch, unsigned char enable)
Definition: ftdi.cpp:306
int set_dtr(bool state)
Definition: ftdi.cpp:272
int set_latency(unsigned char latency)
Definition: ftdi.cpp:282
int set_read_chunk_size(unsigned int chunksize)
Definition: ftdi.cpp:222
int open(struct libusb_device *dev=0)
Definition: ftdi.cpp:122
int set_event_char(unsigned char eventch, unsigned char enable)
Definition: ftdi.cpp:301
unsigned latency()
Definition: ftdi.cpp:287
unsigned short poll_modem_status()
Definition: ftdi.cpp:294
int set_interface(enum ftdi_interface interface)
Definition: ftdi.cpp:171
int get_strings(bool vendor=true, bool description=true, bool serial=true)
Definition: ftdi.cpp:336
int read_pins(unsigned char *pins)
Definition: ftdi.cpp:326
void set_context(struct ftdi_context *context)
Definition: ftdi.cpp:407
int close()
Definition: ftdi.cpp:133
const std::string & vendor()
Device strings properties.
Definition: ftdi.cpp:382
void set_usb_read_timeout(int usb_read_timeout)
Definition: ftdi.cpp:202
int write(const unsigned char *buf, int size)
Definition: ftdi.cpp:236
int set_line_property(enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
Definition: ftdi.cpp:187
int bitbang_disable()
Definition: ftdi.cpp:321
~Context()
Destructor.
Definition: ftdi.cpp:73
int set_modem_control(int mask=Dtr|Rts)
Definition: ftdi.cpp:260
int write_chunk_size()
Definition: ftdi.cpp:246
int set_bitmode(unsigned char bitmask, unsigned char mode)
Definition: ftdi.cpp:311
int set_rts(bool state)
Definition: ftdi.cpp:277
struct ftdi_context * context()
Definition: ftdi.cpp:418
int get_strings_and_reopen(bool vendor=true, bool description=true, bool serial=true)
Definition: ftdi.cpp:353
int get_usb_write_timeout() const
Definition: ftdi.cpp:207
struct ftdi_context * context
Definition: ftdi.cpp:431
struct ftdi_eeprom eeprom
Definition: ftdi.cpp:430
int erase()
Definition: ftdi.cpp:479
int read(unsigned char *eeprom)
Definition: ftdi.cpp:459
int init_defaults(char *manufacturer, char *product, char *serial)
Definition: ftdi.cpp:444
Eeprom(Context *parent)
Definition: ftdi.cpp:434
int write_location(int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.cpp:474
int read_location(int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.cpp:469
int build(unsigned char *output)
Definition: ftdi.cpp:454
int write(unsigned char *eeprom)
Definition: ftdi.cpp:464
int chip_id(unsigned int *chipid)
Definition: ftdi.cpp:449
Private(struct ftdi_device_list *_devlist)
Definition: ftdi.cpp:487
struct ftdi_device_list * devlist
Definition: ftdi.cpp:498
std::list< Context > list
Definition: ftdi.cpp:497
Device list.
Definition: ftdi.hpp:176
std::list< Context > ListType
List type storing "Context" objects.
Definition: ftdi.hpp:184
void push_back(const Context &element)
Definition: ftdi.cpp:633
void clear()
Definition: ftdi.cpp:617
ListType::const_reverse_iterator const_reverse_iterator
Const reverse iterator type for the container.
Definition: ftdi.hpp:192
iterator begin()
Definition: ftdi.cpp:525
ListType::iterator iterator
Iterator type for the container.
Definition: ftdi.hpp:186
ListType::reverse_iterator reverse_iterator
Reverse iterator type for the container.
Definition: ftdi.hpp:190
iterator erase(iterator pos)
Definition: ftdi.cpp:652
reverse_iterator rbegin()
Definition: ftdi.cpp:561
ListType::const_iterator const_iterator
Const iterator type for the container.
Definition: ftdi.hpp:188
bool empty() const
Definition: ftdi.cpp:607
List(struct ftdi_device_list *devlist=0)
Definition: ftdi.cpp:501
iterator end()
Definition: ftdi.cpp:534
reverse_iterator rend()
Definition: ftdi.cpp:570
static List * find_all(Context &context, int vendor, int product)
Definition: ftdi.cpp:668
void push_front(const Context &element)
Definition: ftdi.cpp:642
ListType::size_type size() const
Definition: ftdi.cpp:598
int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:1484
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
Definition: ftdi.c:1395
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
Definition: ftdi.c:585
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2452
int ftdi_usb_get_strings(struct ftdi_context *ftdi, struct libusb_device *dev, char *manufacturer, int mnf_len, char *description, int desc_len, char *serial, int serial_len)
Definition: ftdi.c:409
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1046
void ftdi_set_usbdev(struct ftdi_context *ftdi, libusb_device_handle *usb)
Definition: ftdi.c:268
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1020
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4532
int ftdi_usb_reset(struct ftdi_context *ftdi)
Definition: ftdi.c:994
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
Definition: ftdi.c:310
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
Definition: ftdi.c:1069
void ftdi_list_free(struct ftdi_device_list **devlist)
Definition: ftdi.c:358
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
Definition: ftdi.c:2247
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial, unsigned int index)
Definition: ftdi.c:755
void ftdi_free(struct ftdi_context *ftdi)
Definition: ftdi.c:256
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
Definition: ftdi.c:2166
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
Definition: ftdi.c:2117
int ftdi_setdtr(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2296
int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type)
Definition: ftdi.c:1414
int ftdi_setrts(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2326
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:1884
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
Definition: ftdi.c:2357
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.c:4421
int ftdi_read_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.c:4300
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:2033
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
Definition: ftdi.c:157
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable)
Definition: ftdi.c:2393
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1908
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
Definition: ftdi.c:2091
const char * ftdi_get_error_string(struct ftdi_context *ftdi)
Definition: ftdi.c:4594
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:1866
int ftdi_write_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4477
int ftdi_usb_close(struct ftdi_context *ftdi)
Definition: ftdi.c:1098
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
Definition: ftdi.c:698
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char *description)
Definition: ftdi.c:901
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:2070
struct ftdi_context * ftdi_new(void)
Definition: ftdi.c:128
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
Definition: ftdi.c:2140
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
Definition: ftdi.c:4383
int ftdi_read_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4324
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
Definition: ftdi.c:2273
int ftdi_eeprom_build(struct ftdi_context *ftdi)
Definition: ftdi.c:2783
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
Definition: ftdi.c:2193
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
Definition: ftdi.c:1349
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable)
Definition: ftdi.c:2422
ftdi_mpsse_mode
Definition: ftdi.h:60
ftdi_stopbits_type
Definition: ftdi.h:52
ftdi_bits_type
Definition: ftdi.h:54
ftdi_interface
Definition: ftdi.h:75
ftdi_parity_type
Definition: ftdi.h:50
ftdi_break_type
Definition: ftdi.h:56
Definition: ftdi.cpp:35
Main context structure for all libftdi functions.
Definition: ftdi.h:222
struct ftdi_eeprom * eeprom
Definition: ftdi.h:267
list of usb devices created by ftdi_usb_find_all()
Definition: ftdi.h:345
struct ftdi_device_list * next
Definition: ftdi.h:347
struct libusb_device * dev
Definition: ftdi.h:349
FTDI eeprom structure.
Definition: ftdi_i.h:31