ftdi_stream: fix timeout setting: tv_usec field of timeval is in microseconds, not ms
[libftdi] / src / ftdi.c
1 /***************************************************************************
2                           ftdi.c  -  description
3                              -------------------
4     begin                : Fri Apr 4 2003
5     copyright            : (C) 2003-2014 by Intra2net AG and the libftdi developers
6     email                : opensource@intra2net.com
7  ***************************************************************************/
8
9 /***************************************************************************
10  *                                                                         *
11  *   This program is free software; you can redistribute it and/or modify  *
12  *   it under the terms of the GNU Lesser General Public License           *
13  *   version 2.1 as published by the Free Software Foundation;             *
14  *                                                                         *
15  ***************************************************************************/
16
17 /**
18     \mainpage libftdi API documentation
19
20     Library to talk to FTDI chips. You find the latest versions of libftdi at
21     http://www.intra2net.com/en/developer/libftdi/
22
23     The library is easy to use. Have a look at this short example:
24     \include simple.c
25
26     More examples can be found in the "examples" directory.
27 */
28 /** \addtogroup libftdi */
29 /* @{ */
30
31 #include <libusb.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36
37 #include "ftdi_i.h"
38 #include "ftdi.h"
39 #include "ftdi_version_i.h"
40
41 #define ftdi_error_return(code, str) do {  \
42         if ( ftdi )                        \
43             ftdi->error_str = str;         \
44         else                               \
45             fprintf(stderr, str);          \
46         return code;                       \
47    } while(0);
48
49 #define ftdi_error_return_free_device_list(code, str, devs) do {    \
50         libusb_free_device_list(devs,1);   \
51         ftdi->error_str = str;             \
52         return code;                       \
53    } while(0);
54
55
56 /**
57     Internal function to close usb device pointer.
58     Sets ftdi->usb_dev to NULL.
59     \internal
60
61     \param ftdi pointer to ftdi_context
62
63     \retval none
64 */
65 static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
66 {
67     if (ftdi && ftdi->usb_dev)
68     {
69         libusb_close (ftdi->usb_dev);
70         ftdi->usb_dev = NULL;
71         if(ftdi->eeprom)
72             ftdi->eeprom->initialized_for_connected_device = 0;
73     }
74 }
75
76 /**
77     Initializes a ftdi_context.
78
79     \param ftdi pointer to ftdi_context
80
81     \retval  0: all fine
82     \retval -1: couldn't allocate read buffer
83     \retval -2: couldn't allocate struct  buffer
84     \retval -3: libusb_init() failed
85
86     \remark This should be called before all functions
87 */
88 int ftdi_init(struct ftdi_context *ftdi)
89 {
90     struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
91     ftdi->usb_ctx = NULL;
92     ftdi->usb_dev = NULL;
93     ftdi->usb_read_timeout = 5000;
94     ftdi->usb_write_timeout = 5000;
95
96     ftdi->type = TYPE_BM;    /* chip type */
97     ftdi->baudrate = -1;
98     ftdi->bitbang_enabled = 0;  /* 0: normal mode 1: any of the bitbang modes enabled */
99
100     ftdi->readbuffer = NULL;
101     ftdi->readbuffer_offset = 0;
102     ftdi->readbuffer_remaining = 0;
103     ftdi->writebuffer_chunksize = 4096;
104     ftdi->max_packet_size = 0;
105     ftdi->error_str = NULL;
106     ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
107
108     if (libusb_init(&ftdi->usb_ctx) < 0)
109         ftdi_error_return(-3, "libusb_init() failed");
110
111     ftdi_set_interface(ftdi, INTERFACE_ANY);
112     ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode  */
113
114     if (eeprom == 0)
115         ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
116     memset(eeprom, 0, sizeof(struct ftdi_eeprom));
117     ftdi->eeprom = eeprom;
118
119     /* All fine. Now allocate the readbuffer */
120     return ftdi_read_data_set_chunksize(ftdi, 4096);
121 }
122
123 /**
124     Allocate and initialize a new ftdi_context
125
126     \return a pointer to a new ftdi_context, or NULL on failure
127 */
128 struct ftdi_context *ftdi_new(void)
129 {
130     struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
131
132     if (ftdi == NULL)
133     {
134         return NULL;
135     }
136
137     if (ftdi_init(ftdi) != 0)
138     {
139         free(ftdi);
140         return NULL;
141     }
142
143     return ftdi;
144 }
145
146 /**
147     Open selected channels on a chip, otherwise use first channel.
148
149     \param ftdi pointer to ftdi_context
150     \param interface Interface to use for FT2232C/2232H/4232H chips.
151
152     \retval  0: all fine
153     \retval -1: unknown interface
154     \retval -2: USB device unavailable
155     \retval -3: Device already open, interface can't be set in that state
156 */
157 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
158 {
159     if (ftdi == NULL)
160         ftdi_error_return(-2, "USB device unavailable");
161
162     if (ftdi->usb_dev != NULL)
163     {
164         int check_interface = interface;
165         if (check_interface == INTERFACE_ANY)
166             check_interface = INTERFACE_A;
167
168         if (ftdi->index != check_interface)
169             ftdi_error_return(-3, "Interface can not be changed on an already open device");
170     }
171
172     switch (interface)
173     {
174         case INTERFACE_ANY:
175         case INTERFACE_A:
176             ftdi->interface = 0;
177             ftdi->index     = INTERFACE_A;
178             ftdi->in_ep     = 0x02;
179             ftdi->out_ep    = 0x81;
180             break;
181         case INTERFACE_B:
182             ftdi->interface = 1;
183             ftdi->index     = INTERFACE_B;
184             ftdi->in_ep     = 0x04;
185             ftdi->out_ep    = 0x83;
186             break;
187         case INTERFACE_C:
188             ftdi->interface = 2;
189             ftdi->index     = INTERFACE_C;
190             ftdi->in_ep     = 0x06;
191             ftdi->out_ep    = 0x85;
192             break;
193         case INTERFACE_D:
194             ftdi->interface = 3;
195             ftdi->index     = INTERFACE_D;
196             ftdi->in_ep     = 0x08;
197             ftdi->out_ep    = 0x87;
198             break;
199         default:
200             ftdi_error_return(-1, "Unknown interface");
201     }
202     return 0;
203 }
204
205 /**
206     Deinitializes a ftdi_context.
207
208     \param ftdi pointer to ftdi_context
209 */
210 void ftdi_deinit(struct ftdi_context *ftdi)
211 {
212     if (ftdi == NULL)
213         return;
214
215     ftdi_usb_close_internal (ftdi);
216
217     if (ftdi->readbuffer != NULL)
218     {
219         free(ftdi->readbuffer);
220         ftdi->readbuffer = NULL;
221     }
222
223     if (ftdi->eeprom != NULL)
224     {
225         if (ftdi->eeprom->manufacturer != 0)
226         {
227             free(ftdi->eeprom->manufacturer);
228             ftdi->eeprom->manufacturer = 0;
229         }
230         if (ftdi->eeprom->product != 0)
231         {
232             free(ftdi->eeprom->product);
233             ftdi->eeprom->product = 0;
234         }
235         if (ftdi->eeprom->serial != 0)
236         {
237             free(ftdi->eeprom->serial);
238             ftdi->eeprom->serial = 0;
239         }
240         free(ftdi->eeprom);
241         ftdi->eeprom = NULL;
242     }
243
244     if (ftdi->usb_ctx)
245     {
246         libusb_exit(ftdi->usb_ctx);
247         ftdi->usb_ctx = NULL;
248     }
249 }
250
251 /**
252     Deinitialize and free an ftdi_context.
253
254     \param ftdi pointer to ftdi_context
255 */
256 void ftdi_free(struct ftdi_context *ftdi)
257 {
258     ftdi_deinit(ftdi);
259     free(ftdi);
260 }
261
262 /**
263     Use an already open libusb device.
264
265     \param ftdi pointer to ftdi_context
266     \param usb libusb libusb_device_handle to use
267 */
268 void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
269 {
270     if (ftdi == NULL)
271         return;
272
273     ftdi->usb_dev = usb;
274 }
275
276 /**
277  * @brief Get libftdi library version
278  *
279  * @return ftdi_version_info Library version information
280  **/
281 struct ftdi_version_info ftdi_get_library_version(void)
282 {
283     struct ftdi_version_info ver;
284
285     ver.major = FTDI_MAJOR_VERSION;
286     ver.minor = FTDI_MINOR_VERSION;
287     ver.micro = FTDI_MICRO_VERSION;
288     ver.version_str = FTDI_VERSION_STRING;
289     ver.snapshot_str = FTDI_SNAPSHOT_VERSION;
290
291     return ver;
292 }
293
294 /**
295     Finds all ftdi devices with given VID:PID on the usb bus. Creates a new
296     ftdi_device_list which needs to be deallocated by ftdi_list_free() after
297     use.  With VID:PID 0:0, search for the default devices
298     (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014, 0x403:0x6015)
299
300     \param ftdi pointer to ftdi_context
301     \param devlist Pointer where to store list of found devices
302     \param vendor Vendor ID to search for
303     \param product Product ID to search for
304
305     \retval >0: number of devices found
306     \retval -3: out of memory
307     \retval -5: libusb_get_device_list() failed
308     \retval -6: libusb_get_device_descriptor() failed
309 */
310 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
311 {
312     struct ftdi_device_list **curdev;
313     libusb_device *dev;
314     libusb_device **devs;
315     int count = 0;
316     int i = 0;
317
318     if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
319         ftdi_error_return(-5, "libusb_get_device_list() failed");
320
321     curdev = devlist;
322     *curdev = NULL;
323
324     while ((dev = devs[i++]) != NULL)
325     {
326         struct libusb_device_descriptor desc;
327
328         if (libusb_get_device_descriptor(dev, &desc) < 0)
329             ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
330
331         if (((vendor || product) &&
332                 desc.idVendor == vendor && desc.idProduct == product) ||
333                 (!(vendor || product) &&
334                  (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
335                                               || desc.idProduct == 0x6011 || desc.idProduct == 0x6014
336                                               || desc.idProduct == 0x6015)))
337         {
338             *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
339             if (!*curdev)
340                 ftdi_error_return_free_device_list(-3, "out of memory", devs);
341
342             (*curdev)->next = NULL;
343             (*curdev)->dev = dev;
344             libusb_ref_device(dev);
345             curdev = &(*curdev)->next;
346             count++;
347         }
348     }
349     libusb_free_device_list(devs,1);
350     return count;
351 }
352
353 /**
354     Frees a usb device list.
355
356     \param devlist USB device list created by ftdi_usb_find_all()
357 */
358 void ftdi_list_free(struct ftdi_device_list **devlist)
359 {
360     struct ftdi_device_list *curdev, *next;
361
362     for (curdev = *devlist; curdev != NULL;)
363     {
364         next = curdev->next;
365         libusb_unref_device(curdev->dev);
366         free(curdev);
367         curdev = next;
368     }
369
370     *devlist = NULL;
371 }
372
373 /**
374     Frees a usb device list.
375
376     \param devlist USB device list created by ftdi_usb_find_all()
377 */
378 void ftdi_list_free2(struct ftdi_device_list *devlist)
379 {
380     ftdi_list_free(&devlist);
381 }
382
383 /**
384     Return device ID strings from the usb device.
385
386     The parameters manufacturer, description and serial may be NULL
387     or pointer to buffers to store the fetched strings.
388
389     \note Use this function only in combination with ftdi_usb_find_all()
390           as it closes the internal "usb_dev" after use.
391
392     \param ftdi pointer to ftdi_context
393     \param dev libusb usb_dev to use
394     \param manufacturer Store manufacturer string here if not NULL
395     \param mnf_len Buffer size of manufacturer string
396     \param description Store product description string here if not NULL
397     \param desc_len Buffer size of product description string
398     \param serial Store serial string here if not NULL
399     \param serial_len Buffer size of serial string
400
401     \retval   0: all fine
402     \retval  -1: wrong arguments
403     \retval  -4: unable to open device
404     \retval  -7: get product manufacturer failed
405     \retval  -8: get product description failed
406     \retval  -9: get serial number failed
407     \retval -11: libusb_get_device_descriptor() failed
408 */
409 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
410                          char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
411 {
412     struct libusb_device_descriptor desc;
413
414     if ((ftdi==NULL) || (dev==NULL))
415         return -1;
416
417     if (ftdi->usb_dev == NULL && libusb_open(dev, &ftdi->usb_dev) < 0)
418             ftdi_error_return(-4, "libusb_open() failed");
419
420     if (libusb_get_device_descriptor(dev, &desc) < 0)
421         ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
422
423     if (manufacturer != NULL)
424     {
425         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
426         {
427             ftdi_usb_close_internal (ftdi);
428             ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
429         }
430     }
431
432     if (description != NULL)
433     {
434         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
435         {
436             ftdi_usb_close_internal (ftdi);
437             ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
438         }
439     }
440
441     if (serial != NULL)
442     {
443         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
444         {
445             ftdi_usb_close_internal (ftdi);
446             ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
447         }
448     }
449
450     ftdi_usb_close_internal (ftdi);
451
452     return 0;
453 }
454
455 /**
456  * Internal function to determine the maximum packet size.
457  * \param ftdi pointer to ftdi_context
458  * \param dev libusb usb_dev to use
459  * \retval Maximum packet size for this device
460  */
461 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
462 {
463     struct libusb_device_descriptor desc;
464     struct libusb_config_descriptor *config0;
465     unsigned int packet_size;
466
467     // Sanity check
468     if (ftdi == NULL || dev == NULL)
469         return 64;
470
471     // Determine maximum packet size. Init with default value.
472     // New hi-speed devices from FTDI use a packet size of 512 bytes
473     // but could be connected to a normal speed USB hub -> 64 bytes packet size.
474     if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
475         packet_size = 512;
476     else
477         packet_size = 64;
478
479     if (libusb_get_device_descriptor(dev, &desc) < 0)
480         return packet_size;
481
482     if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
483         return packet_size;
484
485     if (desc.bNumConfigurations > 0)
486     {
487         if (ftdi->interface < config0->bNumInterfaces)
488         {
489             struct libusb_interface interface = config0->interface[ftdi->interface];
490             if (interface.num_altsetting > 0)
491             {
492                 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
493                 if (descriptor.bNumEndpoints > 0)
494                 {
495                     packet_size = descriptor.endpoint[0].wMaxPacketSize;
496                 }
497             }
498         }
499     }
500
501     libusb_free_config_descriptor (config0);
502     return packet_size;
503 }
504
505 /**
506     Opens a ftdi device given by an usb_device.
507
508     \param ftdi pointer to ftdi_context
509     \param dev libusb usb_dev to use
510
511     \retval  0: all fine
512     \retval -3: unable to config device
513     \retval -4: unable to open device
514     \retval -5: unable to claim device
515     \retval -6: reset failed
516     \retval -7: set baudrate failed
517     \retval -8: ftdi context invalid
518     \retval -9: libusb_get_device_descriptor() failed
519     \retval -10: libusb_get_config_descriptor() failed
520     \retval -11: libusb_detach_kernel_driver() failed
521     \retval -12: libusb_get_configuration() failed
522 */
523 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
524 {
525     struct libusb_device_descriptor desc;
526     struct libusb_config_descriptor *config0;
527     int cfg, cfg0, detach_errno = 0;
528
529     if (ftdi == NULL)
530         ftdi_error_return(-8, "ftdi context invalid");
531
532     if (libusb_open(dev, &ftdi->usb_dev) < 0)
533         ftdi_error_return(-4, "libusb_open() failed");
534
535     if (libusb_get_device_descriptor(dev, &desc) < 0)
536         ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
537
538     if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
539         ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
540     cfg0 = config0->bConfigurationValue;
541     libusb_free_config_descriptor (config0);
542
543     // Try to detach ftdi_sio kernel module.
544     //
545     // The return code is kept in a separate variable and only parsed
546     // if usb_set_configuration() or usb_claim_interface() fails as the
547     // detach operation might be denied and everything still works fine.
548     // Likely scenario is a static ftdi_sio kernel module.
549     if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
550     {
551         if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
552             detach_errno = errno;
553     }
554
555     if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
556         ftdi_error_return(-12, "libusb_get_configuration () failed");
557     // set configuration (needed especially for windows)
558     // tolerate EBUSY: one device with one configuration, but two interfaces
559     //    and libftdi sessions to both interfaces (e.g. FT2232)
560     if (desc.bNumConfigurations > 0 && cfg != cfg0)
561     {
562         if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
563         {
564             ftdi_usb_close_internal (ftdi);
565             if (detach_errno == EPERM)
566             {
567                 ftdi_error_return(-8, "inappropriate permissions on device!");
568             }
569             else
570             {
571                 ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
572             }
573         }
574     }
575
576     if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
577     {
578         ftdi_usb_close_internal (ftdi);
579         if (detach_errno == EPERM)
580         {
581             ftdi_error_return(-8, "inappropriate permissions on device!");
582         }
583         else
584         {
585             ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
586         }
587     }
588
589     if (ftdi_usb_reset (ftdi) != 0)
590     {
591         ftdi_usb_close_internal (ftdi);
592         ftdi_error_return(-6, "ftdi_usb_reset failed");
593     }
594
595     // Try to guess chip type
596     // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
597     if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
598                                     && desc.iSerialNumber == 0))
599         ftdi->type = TYPE_BM;
600     else if (desc.bcdDevice == 0x200)
601         ftdi->type = TYPE_AM;
602     else if (desc.bcdDevice == 0x500)
603         ftdi->type = TYPE_2232C;
604     else if (desc.bcdDevice == 0x600)
605         ftdi->type = TYPE_R;
606     else if (desc.bcdDevice == 0x700)
607         ftdi->type = TYPE_2232H;
608     else if (desc.bcdDevice == 0x800)
609         ftdi->type = TYPE_4232H;
610     else if (desc.bcdDevice == 0x900)
611         ftdi->type = TYPE_232H;
612     else if (desc.bcdDevice == 0x1000)
613         ftdi->type = TYPE_230X;
614
615     // Determine maximum packet size
616     ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
617
618     if (ftdi_set_baudrate (ftdi, 9600) != 0)
619     {
620         ftdi_usb_close_internal (ftdi);
621         ftdi_error_return(-7, "set baudrate failed");
622     }
623
624     ftdi_error_return(0, "all fine");
625 }
626
627 /**
628     Opens the first device with a given vendor and product ids.
629
630     \param ftdi pointer to ftdi_context
631     \param vendor Vendor ID
632     \param product Product ID
633
634     \retval same as ftdi_usb_open_desc()
635 */
636 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
637 {
638     return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
639 }
640
641 /**
642     Opens the first device with a given, vendor id, product id,
643     description and serial.
644
645     \param ftdi pointer to ftdi_context
646     \param vendor Vendor ID
647     \param product Product ID
648     \param description Description to search for. Use NULL if not needed.
649     \param serial Serial to search for. Use NULL if not needed.
650
651     \retval  0: all fine
652     \retval -3: usb device not found
653     \retval -4: unable to open device
654     \retval -5: unable to claim device
655     \retval -6: reset failed
656     \retval -7: set baudrate failed
657     \retval -8: get product description failed
658     \retval -9: get serial number failed
659     \retval -12: libusb_get_device_list() failed
660     \retval -13: libusb_get_device_descriptor() failed
661 */
662 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
663                        const char* description, const char* serial)
664 {
665     return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
666 }
667
668 /**
669     Opens the index-th device with a given, vendor id, product id,
670     description and serial.
671
672     \param ftdi pointer to ftdi_context
673     \param vendor Vendor ID
674     \param product Product ID
675     \param description Description to search for. Use NULL if not needed.
676     \param serial Serial to search for. Use NULL if not needed.
677     \param index Number of matching device to open if there are more than one, starts with 0.
678
679     \retval  0: all fine
680     \retval -1: usb_find_busses() failed
681     \retval -2: usb_find_devices() failed
682     \retval -3: usb device not found
683     \retval -4: unable to open device
684     \retval -5: unable to claim device
685     \retval -6: reset failed
686     \retval -7: set baudrate failed
687     \retval -8: get product description failed
688     \retval -9: get serial number failed
689     \retval -10: unable to close device
690     \retval -11: ftdi context invalid
691 */
692 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
693                              const char* description, const char* serial, unsigned int index)
694 {
695     libusb_device *dev;
696     libusb_device **devs;
697     char string[256];
698     int i = 0;
699
700     if (ftdi == NULL)
701         ftdi_error_return(-11, "ftdi context invalid");
702
703     if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
704         ftdi_error_return(-12, "libusb_get_device_list() failed");
705
706     while ((dev = devs[i++]) != NULL)
707     {
708         struct libusb_device_descriptor desc;
709         int res;
710
711         if (libusb_get_device_descriptor(dev, &desc) < 0)
712             ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
713
714         if (desc.idVendor == vendor && desc.idProduct == product)
715         {
716             if (libusb_open(dev, &ftdi->usb_dev) < 0)
717                 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
718
719             if (description != NULL)
720             {
721                 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
722                 {
723                     ftdi_usb_close_internal (ftdi);
724                     ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
725                 }
726                 if (strncmp(string, description, sizeof(string)) != 0)
727                 {
728                     ftdi_usb_close_internal (ftdi);
729                     continue;
730                 }
731             }
732             if (serial != NULL)
733             {
734                 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
735                 {
736                     ftdi_usb_close_internal (ftdi);
737                     ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
738                 }
739                 if (strncmp(string, serial, sizeof(string)) != 0)
740                 {
741                     ftdi_usb_close_internal (ftdi);
742                     continue;
743                 }
744             }
745
746             ftdi_usb_close_internal (ftdi);
747
748             if (index > 0)
749             {
750                 index--;
751                 continue;
752             }
753
754             res = ftdi_usb_open_dev(ftdi, dev);
755             libusb_free_device_list(devs,1);
756             return res;
757         }
758     }
759
760     // device not found
761     ftdi_error_return_free_device_list(-3, "device not found", devs);
762 }
763
764 /**
765     Opens the ftdi-device described by a description-string.
766     Intended to be used for parsing a device-description given as commandline argument.
767
768     \param ftdi pointer to ftdi_context
769     \param description NULL-terminated description-string, using this format:
770         \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
771         \li <tt>i:\<vendor>:\<product></tt> first device with given vendor and product id, ids can be decimal, octal (preceded by "0") or hex (preceded by "0x")
772         \li <tt>i:\<vendor>:\<product>:\<index></tt> as above with index being the number of the device (starting with 0) if there are more than one
773         \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
774
775     \note The description format may be extended in later versions.
776
777     \retval  0: all fine
778     \retval -2: libusb_get_device_list() failed
779     \retval -3: usb device not found
780     \retval -4: unable to open device
781     \retval -5: unable to claim device
782     \retval -6: reset failed
783     \retval -7: set baudrate failed
784     \retval -8: get product description failed
785     \retval -9: get serial number failed
786     \retval -10: unable to close device
787     \retval -11: illegal description format
788     \retval -12: ftdi context invalid
789 */
790 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
791 {
792     if (ftdi == NULL)
793         ftdi_error_return(-12, "ftdi context invalid");
794
795     if (description[0] == 0 || description[1] != ':')
796         ftdi_error_return(-11, "illegal description format");
797
798     if (description[0] == 'd')
799     {
800         libusb_device *dev;
801         libusb_device **devs;
802         unsigned int bus_number, device_address;
803         int i = 0;
804
805         if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
806             ftdi_error_return(-2, "libusb_get_device_list() failed");
807
808         /* XXX: This doesn't handle symlinks/odd paths/etc... */
809         if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
810             ftdi_error_return_free_device_list(-11, "illegal description format", devs);
811
812         while ((dev = devs[i++]) != NULL)
813         {
814             int ret;
815             if (bus_number == libusb_get_bus_number (dev)
816                     && device_address == libusb_get_device_address (dev))
817             {
818                 ret = ftdi_usb_open_dev(ftdi, dev);
819                 libusb_free_device_list(devs,1);
820                 return ret;
821             }
822         }
823
824         // device not found
825         ftdi_error_return_free_device_list(-3, "device not found", devs);
826     }
827     else if (description[0] == 'i' || description[0] == 's')
828     {
829         unsigned int vendor;
830         unsigned int product;
831         unsigned int index=0;
832         const char *serial=NULL;
833         const char *startp, *endp;
834
835         errno=0;
836         startp=description+2;
837         vendor=strtoul((char*)startp,(char**)&endp,0);
838         if (*endp != ':' || endp == startp || errno != 0)
839             ftdi_error_return(-11, "illegal description format");
840
841         startp=endp+1;
842         product=strtoul((char*)startp,(char**)&endp,0);
843         if (endp == startp || errno != 0)
844             ftdi_error_return(-11, "illegal description format");
845
846         if (description[0] == 'i' && *endp != 0)
847         {
848             /* optional index field in i-mode */
849             if (*endp != ':')
850                 ftdi_error_return(-11, "illegal description format");
851
852             startp=endp+1;
853             index=strtoul((char*)startp,(char**)&endp,0);
854             if (*endp != 0 || endp == startp || errno != 0)
855                 ftdi_error_return(-11, "illegal description format");
856         }
857         if (description[0] == 's')
858         {
859             if (*endp != ':')
860                 ftdi_error_return(-11, "illegal description format");
861
862             /* rest of the description is the serial */
863             serial=endp+1;
864         }
865
866         return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
867     }
868     else
869     {
870         ftdi_error_return(-11, "illegal description format");
871     }
872 }
873
874 /**
875     Resets the ftdi device.
876
877     \param ftdi pointer to ftdi_context
878
879     \retval  0: all fine
880     \retval -1: FTDI reset failed
881     \retval -2: USB device unavailable
882 */
883 int ftdi_usb_reset(struct ftdi_context *ftdi)
884 {
885     if (ftdi == NULL || ftdi->usb_dev == NULL)
886         ftdi_error_return(-2, "USB device unavailable");
887
888     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
889                                 SIO_RESET_REQUEST, SIO_RESET_SIO,
890                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
891         ftdi_error_return(-1,"FTDI reset failed");
892
893     // Invalidate data in the readbuffer
894     ftdi->readbuffer_offset = 0;
895     ftdi->readbuffer_remaining = 0;
896
897     return 0;
898 }
899
900 /**
901     Clears the read buffer on the chip and the internal read buffer.
902
903     \param ftdi pointer to ftdi_context
904
905     \retval  0: all fine
906     \retval -1: read buffer purge failed
907     \retval -2: USB device unavailable
908 */
909 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
910 {
911     if (ftdi == NULL || ftdi->usb_dev == NULL)
912         ftdi_error_return(-2, "USB device unavailable");
913
914     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
915                                 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
916                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
917         ftdi_error_return(-1, "FTDI purge of RX buffer failed");
918
919     // Invalidate data in the readbuffer
920     ftdi->readbuffer_offset = 0;
921     ftdi->readbuffer_remaining = 0;
922
923     return 0;
924 }
925
926 /**
927     Clears the write buffer on the chip.
928
929     \param ftdi pointer to ftdi_context
930
931     \retval  0: all fine
932     \retval -1: write buffer purge failed
933     \retval -2: USB device unavailable
934 */
935 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
936 {
937     if (ftdi == NULL || ftdi->usb_dev == NULL)
938         ftdi_error_return(-2, "USB device unavailable");
939
940     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
941                                 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
942                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
943         ftdi_error_return(-1, "FTDI purge of TX buffer failed");
944
945     return 0;
946 }
947
948 /**
949     Clears the buffers on the chip and the internal read buffer.
950
951     \param ftdi pointer to ftdi_context
952
953     \retval  0: all fine
954     \retval -1: read buffer purge failed
955     \retval -2: write buffer purge failed
956     \retval -3: USB device unavailable
957 */
958 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
959 {
960     int result;
961
962     if (ftdi == NULL || ftdi->usb_dev == NULL)
963         ftdi_error_return(-3, "USB device unavailable");
964
965     result = ftdi_usb_purge_rx_buffer(ftdi);
966     if (result < 0)
967         return -1;
968
969     result = ftdi_usb_purge_tx_buffer(ftdi);
970     if (result < 0)
971         return -2;
972
973     return 0;
974 }
975
976
977
978 /**
979     Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
980
981     \param ftdi pointer to ftdi_context
982
983     \retval  0: all fine
984     \retval -1: usb_release failed
985     \retval -3: ftdi context invalid
986 */
987 int ftdi_usb_close(struct ftdi_context *ftdi)
988 {
989     int rtn = 0;
990
991     if (ftdi == NULL)
992         ftdi_error_return(-3, "ftdi context invalid");
993
994     if (ftdi->usb_dev != NULL)
995         if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
996             rtn = -1;
997
998     ftdi_usb_close_internal (ftdi);
999
1000     return rtn;
1001 }
1002
1003 /*  ftdi_to_clkbits_AM For the AM device, convert a requested baudrate
1004                     to encoded divisor and the achievable baudrate
1005     Function is only used internally
1006     \internal
1007
1008     See AN120
1009    clk/1   -> 0
1010    clk/1.5 -> 1
1011    clk/2   -> 2
1012    From /2, 0.125/ 0.25 and 0.5 steps may be taken
1013    The fractional part has frac_code encoding
1014 */
1015 static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor)
1016
1017 {
1018     static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1019     static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
1020     static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
1021     int divisor, best_divisor, best_baud, best_baud_diff;
1022     int i;
1023     divisor = 24000000 / baudrate;
1024
1025     // Round down to supported fraction (AM only)
1026     divisor -= am_adjust_dn[divisor & 7];
1027
1028     // Try this divisor and the one above it (because division rounds down)
1029     best_divisor = 0;
1030     best_baud = 0;
1031     best_baud_diff = 0;
1032     for (i = 0; i < 2; i++)
1033     {
1034         int try_divisor = divisor + i;
1035         int baud_estimate;
1036         int baud_diff;
1037
1038         // Round up to supported divisor value
1039         if (try_divisor <= 8)
1040         {
1041             // Round up to minimum supported divisor
1042             try_divisor = 8;
1043         }
1044         else if (divisor < 16)
1045         {
1046             // AM doesn't support divisors 9 through 15 inclusive
1047             try_divisor = 16;
1048         }
1049         else
1050         {
1051             // Round up to supported fraction (AM only)
1052             try_divisor += am_adjust_up[try_divisor & 7];
1053             if (try_divisor > 0x1FFF8)
1054             {
1055                 // Round down to maximum supported divisor value (for AM)
1056                 try_divisor = 0x1FFF8;
1057             }
1058         }
1059         // Get estimated baud rate (to nearest integer)
1060         baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1061         // Get absolute difference from requested baud rate
1062         if (baud_estimate < baudrate)
1063         {
1064             baud_diff = baudrate - baud_estimate;
1065         }
1066         else
1067         {
1068             baud_diff = baud_estimate - baudrate;
1069         }
1070         if (i == 0 || baud_diff < best_baud_diff)
1071         {
1072             // Closest to requested baud rate so far
1073             best_divisor = try_divisor;
1074             best_baud = baud_estimate;
1075             best_baud_diff = baud_diff;
1076             if (baud_diff == 0)
1077             {
1078                 // Spot on! No point trying
1079                 break;
1080             }
1081         }
1082     }
1083     // Encode the best divisor value
1084     *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1085     // Deal with special cases for encoded value
1086     if (*encoded_divisor == 1)
1087     {
1088         *encoded_divisor = 0;    // 3000000 baud
1089     }
1090     else if (*encoded_divisor == 0x4001)
1091     {
1092         *encoded_divisor = 1;    // 2000000 baud (BM only)
1093     }
1094     return best_baud;
1095 }
1096
1097 /*  ftdi_to_clkbits Convert a requested baudrate for a given system clock  and predivisor
1098                     to encoded divisor and the achievable baudrate
1099     Function is only used internally
1100     \internal
1101
1102     See AN120
1103    clk/1   -> 0
1104    clk/1.5 -> 1
1105    clk/2   -> 2
1106    From /2, 0.125 steps may be taken.
1107    The fractional part has frac_code encoding
1108
1109    value[13:0] of value is the divisor
1110    index[9] mean 12 MHz Base(120 MHz/10) rate versus 3 MHz (48 MHz/16) else
1111
1112    H Type have all features above with
1113    {index[8],value[15:14]} is the encoded subdivisor
1114
1115    FT232R, FT2232 and FT232BM have no option for 12 MHz and with
1116    {index[0],value[15:14]} is the encoded subdivisor
1117
1118    AM Type chips have only four fractional subdivisors at value[15:14]
1119    for subdivisors 0, 0.5, 0.25, 0.125
1120 */
1121 static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor)
1122 {
1123     static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1124     int best_baud = 0;
1125     int divisor, best_divisor;
1126     if (baudrate >=  clk/clk_div)
1127     {
1128         *encoded_divisor = 0;
1129         best_baud = clk/clk_div;
1130     }
1131     else if (baudrate >=  clk/(clk_div + clk_div/2))
1132     {
1133         *encoded_divisor = 1;
1134         best_baud = clk/(clk_div + clk_div/2);
1135     }
1136     else if (baudrate >=  clk/(2*clk_div))
1137     {
1138         *encoded_divisor = 2;
1139         best_baud = clk/(2*clk_div);
1140     }
1141     else
1142     {
1143         /* We divide by 16 to have 3 fractional bits and one bit for rounding */
1144         divisor = clk*16/clk_div / baudrate;
1145         if (divisor & 1) /* Decide if to round up or down*/
1146             best_divisor = divisor /2 +1;
1147         else
1148             best_divisor = divisor/2;
1149         if(best_divisor > 0x20000)
1150             best_divisor = 0x1ffff;
1151         best_baud = clk*16/clk_div/best_divisor;
1152         if (best_baud & 1) /* Decide if to round up or down*/
1153             best_baud = best_baud /2 +1;
1154         else
1155             best_baud = best_baud /2;
1156         *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1157     }
1158     return best_baud;
1159 }
1160 /**
1161     ftdi_convert_baudrate returns nearest supported baud rate to that requested.
1162     Function is only used internally
1163     \internal
1164 */
1165 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
1166                                  unsigned short *value, unsigned short *index)
1167 {
1168     int best_baud;
1169     unsigned long encoded_divisor;
1170
1171     if (baudrate <= 0)
1172     {
1173         // Return error
1174         return -1;
1175     }
1176
1177 #define H_CLK 120000000
1178 #define C_CLK  48000000
1179     if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H))
1180     {
1181         if(baudrate*10 > H_CLK /0x3fff)
1182         {
1183             /* On H Devices, use 12 000 000 Baudrate when possible
1184                We have a 14 bit divisor, a 1 bit divisor switch (10 or 16)
1185                three fractional bits and a 120 MHz clock
1186                Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for
1187                DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/
1188             best_baud = ftdi_to_clkbits(baudrate, H_CLK, 10, &encoded_divisor);
1189             encoded_divisor |= 0x20000; /* switch on CLK/10*/
1190         }
1191         else
1192             best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1193     }
1194     else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R ))
1195     {
1196         best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1197     }
1198     else
1199     {
1200         best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
1201     }
1202     // Split into "value" and "index" values
1203     *value = (unsigned short)(encoded_divisor & 0xFFFF);
1204     if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
1205     {
1206         *index = (unsigned short)(encoded_divisor >> 8);
1207         *index &= 0xFF00;
1208         *index |= ftdi->index;
1209     }
1210     else
1211         *index = (unsigned short)(encoded_divisor >> 16);
1212
1213     // Return the nearest baud rate
1214     return best_baud;
1215 }
1216
1217 /**
1218  * @brief Wrapper function to export ftdi_convert_baudrate() to the unit test
1219  * Do not use, it's only for the unit test framework
1220  **/
1221 int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
1222                                unsigned short *value, unsigned short *index)
1223 {
1224     return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1225 }
1226
1227 /**
1228     Sets the chip baud rate
1229
1230     \param ftdi pointer to ftdi_context
1231     \param baudrate baud rate to set
1232
1233     \retval  0: all fine
1234     \retval -1: invalid baudrate
1235     \retval -2: setting baudrate failed
1236     \retval -3: USB device unavailable
1237 */
1238 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1239 {
1240     unsigned short value, index;
1241     int actual_baudrate;
1242
1243     if (ftdi == NULL || ftdi->usb_dev == NULL)
1244         ftdi_error_return(-3, "USB device unavailable");
1245
1246     if (ftdi->bitbang_enabled)
1247     {
1248         baudrate = baudrate*4;
1249     }
1250
1251     actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1252     if (actual_baudrate <= 0)
1253         ftdi_error_return (-1, "Silly baudrate <= 0.");
1254
1255     // Check within tolerance (about 5%)
1256     if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1257             || ((actual_baudrate < baudrate)
1258                 ? (actual_baudrate * 21 < baudrate * 20)
1259                 : (baudrate * 21 < actual_baudrate * 20)))
1260         ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1261
1262     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1263                                 SIO_SET_BAUDRATE_REQUEST, value,
1264                                 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1265         ftdi_error_return (-2, "Setting new baudrate failed");
1266
1267     ftdi->baudrate = baudrate;
1268     return 0;
1269 }
1270
1271 /**
1272     Set (RS232) line characteristics.
1273     The break type can only be set via ftdi_set_line_property2()
1274     and defaults to "off".
1275
1276     \param ftdi pointer to ftdi_context
1277     \param bits Number of bits
1278     \param sbit Number of stop bits
1279     \param parity Parity mode
1280
1281     \retval  0: all fine
1282     \retval -1: Setting line property failed
1283 */
1284 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1285                            enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1286 {
1287     return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1288 }
1289
1290 /**
1291     Set (RS232) line characteristics
1292
1293     \param ftdi pointer to ftdi_context
1294     \param bits Number of bits
1295     \param sbit Number of stop bits
1296     \param parity Parity mode
1297     \param break_type Break type
1298
1299     \retval  0: all fine
1300     \retval -1: Setting line property failed
1301     \retval -2: USB device unavailable
1302 */
1303 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1304                             enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1305                             enum ftdi_break_type break_type)
1306 {
1307     unsigned short value = bits;
1308
1309     if (ftdi == NULL || ftdi->usb_dev == NULL)
1310         ftdi_error_return(-2, "USB device unavailable");
1311
1312     switch (parity)
1313     {
1314         case NONE:
1315             value |= (0x00 << 8);
1316             break;
1317         case ODD:
1318             value |= (0x01 << 8);
1319             break;
1320         case EVEN:
1321             value |= (0x02 << 8);
1322             break;
1323         case MARK:
1324             value |= (0x03 << 8);
1325             break;
1326         case SPACE:
1327             value |= (0x04 << 8);
1328             break;
1329     }
1330
1331     switch (sbit)
1332     {
1333         case STOP_BIT_1:
1334             value |= (0x00 << 11);
1335             break;
1336         case STOP_BIT_15:
1337             value |= (0x01 << 11);
1338             break;
1339         case STOP_BIT_2:
1340             value |= (0x02 << 11);
1341             break;
1342     }
1343
1344     switch (break_type)
1345     {
1346         case BREAK_OFF:
1347             value |= (0x00 << 14);
1348             break;
1349         case BREAK_ON:
1350             value |= (0x01 << 14);
1351             break;
1352     }
1353
1354     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1355                                 SIO_SET_DATA_REQUEST, value,
1356                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1357         ftdi_error_return (-1, "Setting new line property failed");
1358
1359     return 0;
1360 }
1361
1362 /**
1363     Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1364
1365     \param ftdi pointer to ftdi_context
1366     \param buf Buffer with the data
1367     \param size Size of the buffer
1368
1369     \retval -666: USB device unavailable
1370     \retval <0: error code from usb_bulk_write()
1371     \retval >0: number of bytes written
1372 */
1373 int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
1374 {
1375     int offset = 0;
1376     int actual_length;
1377
1378     if (ftdi == NULL || ftdi->usb_dev == NULL)
1379         ftdi_error_return(-666, "USB device unavailable");
1380
1381     while (offset < size)
1382     {
1383         int write_size = ftdi->writebuffer_chunksize;
1384
1385         if (offset+write_size > size)
1386             write_size = size-offset;
1387
1388         if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, (unsigned char *)buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1389             ftdi_error_return(-1, "usb bulk write failed");
1390
1391         offset += actual_length;
1392     }
1393
1394     return offset;
1395 }
1396
1397 static void LIBUSB_CALL ftdi_read_data_cb(struct libusb_transfer *transfer)
1398 {
1399     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1400     struct ftdi_context *ftdi = tc->ftdi;
1401     int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1402
1403     packet_size = ftdi->max_packet_size;
1404
1405     actual_length = transfer->actual_length;
1406
1407     if (actual_length > 2)
1408     {
1409         // skip FTDI status bytes.
1410         // Maybe stored in the future to enable modem use
1411         num_of_chunks = actual_length / packet_size;
1412         chunk_remains = actual_length % packet_size;
1413         //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1414
1415         ftdi->readbuffer_offset += 2;
1416         actual_length -= 2;
1417
1418         if (actual_length > packet_size - 2)
1419         {
1420             for (i = 1; i < num_of_chunks; i++)
1421                 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1422                          ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1423                          packet_size - 2);
1424             if (chunk_remains > 2)
1425             {
1426                 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1427                          ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1428                          chunk_remains-2);
1429                 actual_length -= 2*num_of_chunks;
1430             }
1431             else
1432                 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1433         }
1434
1435         if (actual_length > 0)
1436         {
1437             // data still fits in buf?
1438             if (tc->offset + actual_length <= tc->size)
1439             {
1440                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1441                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1442                 tc->offset += actual_length;
1443
1444                 ftdi->readbuffer_offset = 0;
1445                 ftdi->readbuffer_remaining = 0;
1446
1447                 /* Did we read exactly the right amount of bytes? */
1448                 if (tc->offset == tc->size)
1449                 {
1450                     //printf("read_data exact rem %d offset %d\n",
1451                     //ftdi->readbuffer_remaining, offset);
1452                     tc->completed = 1;
1453                     return;
1454                 }
1455             }
1456             else
1457             {
1458                 // only copy part of the data or size <= readbuffer_chunksize
1459                 int part_size = tc->size - tc->offset;
1460                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1461                 tc->offset += part_size;
1462
1463                 ftdi->readbuffer_offset += part_size;
1464                 ftdi->readbuffer_remaining = actual_length - part_size;
1465
1466                 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1467                 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1468                 tc->completed = 1;
1469                 return;
1470             }
1471         }
1472     }
1473
1474     if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1475         tc->completed = LIBUSB_TRANSFER_CANCELLED;
1476     else
1477     {
1478         ret = libusb_submit_transfer (transfer);
1479         if (ret < 0)
1480             tc->completed = 1;
1481     }
1482 }
1483
1484
1485 static void LIBUSB_CALL ftdi_write_data_cb(struct libusb_transfer *transfer)
1486 {
1487     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1488     struct ftdi_context *ftdi = tc->ftdi;
1489
1490     tc->offset += transfer->actual_length;
1491
1492     if (tc->offset == tc->size)
1493     {
1494         tc->completed = 1;
1495     }
1496     else
1497     {
1498         int write_size = ftdi->writebuffer_chunksize;
1499         int ret;
1500
1501         if (tc->offset + write_size > tc->size)
1502             write_size = tc->size - tc->offset;
1503
1504         transfer->length = write_size;
1505         transfer->buffer = tc->buf + tc->offset;
1506
1507         if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1508             tc->completed = LIBUSB_TRANSFER_CANCELLED;
1509         else
1510         {
1511             ret = libusb_submit_transfer (transfer);
1512             if (ret < 0)
1513                 tc->completed = 1;
1514         }
1515     }
1516 }
1517
1518
1519 /**
1520     Writes data to the chip. Does not wait for completion of the transfer
1521     nor does it make sure that the transfer was successful.
1522
1523     Use libusb 1.0 asynchronous API.
1524
1525     \param ftdi pointer to ftdi_context
1526     \param buf Buffer with the data
1527     \param size Size of the buffer
1528
1529     \retval NULL: Some error happens when submit transfer
1530     \retval !NULL: Pointer to a ftdi_transfer_control
1531 */
1532
1533 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1534 {
1535     struct ftdi_transfer_control *tc;
1536     struct libusb_transfer *transfer;
1537     int write_size, ret;
1538
1539     if (ftdi == NULL || ftdi->usb_dev == NULL)
1540         return NULL;
1541
1542     tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1543     if (!tc)
1544         return NULL;
1545
1546     transfer = libusb_alloc_transfer(0);
1547     if (!transfer)
1548     {
1549         free(tc);
1550         return NULL;
1551     }
1552
1553     tc->ftdi = ftdi;
1554     tc->completed = 0;
1555     tc->buf = buf;
1556     tc->size = size;
1557     tc->offset = 0;
1558
1559     if (size < (int)ftdi->writebuffer_chunksize)
1560         write_size = size;
1561     else
1562         write_size = ftdi->writebuffer_chunksize;
1563
1564     libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1565                               write_size, ftdi_write_data_cb, tc,
1566                               ftdi->usb_write_timeout);
1567     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1568
1569     ret = libusb_submit_transfer(transfer);
1570     if (ret < 0)
1571     {
1572         libusb_free_transfer(transfer);
1573         free(tc);
1574         return NULL;
1575     }
1576     tc->transfer = transfer;
1577
1578     return tc;
1579 }
1580
1581 /**
1582     Reads data from the chip. Does not wait for completion of the transfer
1583     nor does it make sure that the transfer was successful.
1584
1585     Use libusb 1.0 asynchronous API.
1586
1587     \param ftdi pointer to ftdi_context
1588     \param buf Buffer with the data
1589     \param size Size of the buffer
1590
1591     \retval NULL: Some error happens when submit transfer
1592     \retval !NULL: Pointer to a ftdi_transfer_control
1593 */
1594
1595 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1596 {
1597     struct ftdi_transfer_control *tc;
1598     struct libusb_transfer *transfer;
1599     int ret;
1600
1601     if (ftdi == NULL || ftdi->usb_dev == NULL)
1602         return NULL;
1603
1604     tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1605     if (!tc)
1606         return NULL;
1607
1608     tc->ftdi = ftdi;
1609     tc->buf = buf;
1610     tc->size = size;
1611
1612     if (size <= (int)ftdi->readbuffer_remaining)
1613     {
1614         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1615
1616         // Fix offsets
1617         ftdi->readbuffer_remaining -= size;
1618         ftdi->readbuffer_offset += size;
1619
1620         /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1621
1622         tc->completed = 1;
1623         tc->offset = size;
1624         tc->transfer = NULL;
1625         return tc;
1626     }
1627
1628     tc->completed = 0;
1629     if (ftdi->readbuffer_remaining != 0)
1630     {
1631         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1632
1633         tc->offset = ftdi->readbuffer_remaining;
1634     }
1635     else
1636         tc->offset = 0;
1637
1638     transfer = libusb_alloc_transfer(0);
1639     if (!transfer)
1640     {
1641         free (tc);
1642         return NULL;
1643     }
1644
1645     ftdi->readbuffer_remaining = 0;
1646     ftdi->readbuffer_offset = 0;
1647
1648     libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi_read_data_cb, tc, ftdi->usb_read_timeout);
1649     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1650
1651     ret = libusb_submit_transfer(transfer);
1652     if (ret < 0)
1653     {
1654         libusb_free_transfer(transfer);
1655         free (tc);
1656         return NULL;
1657     }
1658     tc->transfer = transfer;
1659
1660     return tc;
1661 }
1662
1663 /**
1664     Wait for completion of the transfer.
1665
1666     Use libusb 1.0 asynchronous API.
1667
1668     \param tc pointer to ftdi_transfer_control
1669
1670     \retval < 0: Some error happens
1671     \retval >= 0: Data size transferred
1672 */
1673
1674 int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1675 {
1676     int ret;
1677     struct timeval to = { 0, 0 };
1678     while (!tc->completed)
1679     {
1680         ret = libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1681                 &to, &tc->completed);
1682         if (ret < 0)
1683         {
1684             if (ret == LIBUSB_ERROR_INTERRUPTED)
1685                 continue;
1686             libusb_cancel_transfer(tc->transfer);
1687             while (!tc->completed)
1688                 if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1689                         &to, &tc->completed) < 0)
1690                     break;
1691             libusb_free_transfer(tc->transfer);
1692             free (tc);
1693             return ret;
1694         }
1695     }
1696
1697     ret = tc->offset;
1698     /**
1699      * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
1700      * at ftdi_read_data_submit(). Therefore, we need to check it here.
1701      **/
1702     if (tc->transfer)
1703     {
1704         if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1705             ret = -1;
1706         libusb_free_transfer(tc->transfer);
1707     }
1708     free(tc);
1709     return ret;
1710 }
1711
1712 /**
1713     Cancel transfer and wait for completion.
1714
1715     Use libusb 1.0 asynchronous API.
1716
1717     \param tc pointer to ftdi_transfer_control
1718     \param to pointer to timeout value or NULL for infinite
1719 */
1720
1721 void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc,
1722                                struct timeval * to)
1723 {
1724     struct timeval tv = { 0, 0 };
1725
1726     if (!tc->completed && tc->transfer != NULL)
1727     {
1728         if (to == NULL)
1729             to = &tv;
1730
1731         libusb_cancel_transfer(tc->transfer);
1732         while (!tc->completed)
1733         {
1734             if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, to, &tc->completed) < 0)
1735                 break;
1736         }
1737     }
1738
1739     if (tc->transfer)
1740         libusb_free_transfer(tc->transfer);
1741
1742     free (tc);
1743 }
1744
1745 /**
1746     Configure write buffer chunk size.
1747     Default is 4096.
1748
1749     \param ftdi pointer to ftdi_context
1750     \param chunksize Chunk size
1751
1752     \retval 0: all fine
1753     \retval -1: ftdi context invalid
1754 */
1755 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1756 {
1757     if (ftdi == NULL)
1758         ftdi_error_return(-1, "ftdi context invalid");
1759
1760     ftdi->writebuffer_chunksize = chunksize;
1761     return 0;
1762 }
1763
1764 /**
1765     Get write buffer chunk size.
1766
1767     \param ftdi pointer to ftdi_context
1768     \param chunksize Pointer to store chunk size in
1769
1770     \retval 0: all fine
1771     \retval -1: ftdi context invalid
1772 */
1773 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1774 {
1775     if (ftdi == NULL)
1776         ftdi_error_return(-1, "ftdi context invalid");
1777
1778     *chunksize = ftdi->writebuffer_chunksize;
1779     return 0;
1780 }
1781
1782 /**
1783     Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1784
1785     Automatically strips the two modem status bytes transfered during every read.
1786
1787     \param ftdi pointer to ftdi_context
1788     \param buf Buffer to store data in
1789     \param size Size of the buffer
1790
1791     \retval -666: USB device unavailable
1792     \retval <0: error code from libusb_bulk_transfer()
1793     \retval  0: no data was available
1794     \retval >0: number of bytes read
1795
1796 */
1797 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1798 {
1799     int offset = 0, ret, i, num_of_chunks, chunk_remains;
1800     int packet_size = ftdi->max_packet_size;
1801     int actual_length = 1;
1802
1803     if (ftdi == NULL || ftdi->usb_dev == NULL)
1804         ftdi_error_return(-666, "USB device unavailable");
1805
1806     // Packet size sanity check (avoid division by zero)
1807     if (packet_size == 0)
1808         ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1809
1810     // everything we want is still in the readbuffer?
1811     if (size <= (int)ftdi->readbuffer_remaining)
1812     {
1813         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1814
1815         // Fix offsets
1816         ftdi->readbuffer_remaining -= size;
1817         ftdi->readbuffer_offset += size;
1818
1819         /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1820
1821         return size;
1822     }
1823     // something still in the readbuffer, but not enough to satisfy 'size'?
1824     if (ftdi->readbuffer_remaining != 0)
1825     {
1826         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1827
1828         // Fix offset
1829         offset += ftdi->readbuffer_remaining;
1830     }
1831     // do the actual USB read
1832     while (offset < size && actual_length > 0)
1833     {
1834         ftdi->readbuffer_remaining = 0;
1835         ftdi->readbuffer_offset = 0;
1836         /* returns how much received */
1837         ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1838         if (ret < 0)
1839             ftdi_error_return(ret, "usb bulk read failed");
1840
1841         if (actual_length > 2)
1842         {
1843             // skip FTDI status bytes.
1844             // Maybe stored in the future to enable modem use
1845             num_of_chunks = actual_length / packet_size;
1846             chunk_remains = actual_length % packet_size;
1847             //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1848
1849             ftdi->readbuffer_offset += 2;
1850             actual_length -= 2;
1851
1852             if (actual_length > packet_size - 2)
1853             {
1854                 for (i = 1; i < num_of_chunks; i++)
1855                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1856                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1857                              packet_size - 2);
1858                 if (chunk_remains > 2)
1859                 {
1860                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1861                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1862                              chunk_remains-2);
1863                     actual_length -= 2*num_of_chunks;
1864                 }
1865                 else
1866                     actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1867             }
1868         }
1869         else if (actual_length <= 2)
1870         {
1871             // no more data to read?
1872             return offset;
1873         }
1874         if (actual_length > 0)
1875         {
1876             // data still fits in buf?
1877             if (offset+actual_length <= size)
1878             {
1879                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1880                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1881                 offset += actual_length;
1882
1883                 /* Did we read exactly the right amount of bytes? */
1884                 if (offset == size)
1885                     //printf("read_data exact rem %d offset %d\n",
1886                     //ftdi->readbuffer_remaining, offset);
1887                     return offset;
1888             }
1889             else
1890             {
1891                 // only copy part of the data or size <= readbuffer_chunksize
1892                 int part_size = size-offset;
1893                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1894
1895                 ftdi->readbuffer_offset += part_size;
1896                 ftdi->readbuffer_remaining = actual_length-part_size;
1897                 offset += part_size;
1898
1899                 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1900                 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1901
1902                 return offset;
1903             }
1904         }
1905     }
1906     // never reached
1907     return -127;
1908 }
1909
1910 /**
1911     Configure read buffer chunk size.
1912     Default is 4096.
1913
1914     Automatically reallocates the buffer.
1915
1916     \param ftdi pointer to ftdi_context
1917     \param chunksize Chunk size
1918
1919     \retval 0: all fine
1920     \retval -1: ftdi context invalid
1921 */
1922 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1923 {
1924     unsigned char *new_buf;
1925
1926     if (ftdi == NULL)
1927         ftdi_error_return(-1, "ftdi context invalid");
1928
1929     // Invalidate all remaining data
1930     ftdi->readbuffer_offset = 0;
1931     ftdi->readbuffer_remaining = 0;
1932 #ifdef __linux__
1933     /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1934        which is defined in libusb-1.0.  Otherwise, each USB read request will
1935        be divided into multiple URBs.  This will cause issues on Linux kernel
1936        older than 2.6.32.  */
1937     if (chunksize > 16384)
1938         chunksize = 16384;
1939 #endif
1940
1941     if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1942         ftdi_error_return(-1, "out of memory for readbuffer");
1943
1944     ftdi->readbuffer = new_buf;
1945     ftdi->readbuffer_chunksize = chunksize;
1946
1947     return 0;
1948 }
1949
1950 /**
1951     Get read buffer chunk size.
1952
1953     \param ftdi pointer to ftdi_context
1954     \param chunksize Pointer to store chunk size in
1955
1956     \retval 0: all fine
1957     \retval -1: FTDI context invalid
1958 */
1959 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1960 {
1961     if (ftdi == NULL)
1962         ftdi_error_return(-1, "FTDI context invalid");
1963
1964     *chunksize = ftdi->readbuffer_chunksize;
1965     return 0;
1966 }
1967
1968 /**
1969     Enable/disable bitbang modes.
1970
1971     \param ftdi pointer to ftdi_context
1972     \param bitmask Bitmask to configure lines.
1973            HIGH/ON value configures a line as output.
1974     \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1975
1976     \retval  0: all fine
1977     \retval -1: can't enable bitbang mode
1978     \retval -2: USB device unavailable
1979 */
1980 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1981 {
1982     unsigned short usb_val;
1983
1984     if (ftdi == NULL || ftdi->usb_dev == NULL)
1985         ftdi_error_return(-2, "USB device unavailable");
1986
1987     usb_val = bitmask; // low byte: bitmask
1988     usb_val |= (mode << 8);
1989     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1990         ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
1991
1992     ftdi->bitbang_mode = mode;
1993     ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1994     return 0;
1995 }
1996
1997 /**
1998     Disable bitbang mode.
1999
2000     \param ftdi pointer to ftdi_context
2001
2002     \retval  0: all fine
2003     \retval -1: can't disable bitbang mode
2004     \retval -2: USB device unavailable
2005 */
2006 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
2007 {
2008     if (ftdi == NULL || ftdi->usb_dev == NULL)
2009         ftdi_error_return(-2, "USB device unavailable");
2010
2011     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2012         ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
2013
2014     ftdi->bitbang_enabled = 0;
2015     return 0;
2016 }
2017
2018
2019 /**
2020     Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
2021
2022     \param ftdi pointer to ftdi_context
2023     \param pins Pointer to store pins into
2024
2025     \retval  0: all fine
2026     \retval -1: read pins failed
2027     \retval -2: USB device unavailable
2028 */
2029 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
2030 {
2031     if (ftdi == NULL || ftdi->usb_dev == NULL)
2032         ftdi_error_return(-2, "USB device unavailable");
2033
2034     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (unsigned char *)pins, 1, ftdi->usb_read_timeout) != 1)
2035         ftdi_error_return(-1, "read pins failed");
2036
2037     return 0;
2038 }
2039
2040 /**
2041     Set latency timer
2042
2043     The FTDI chip keeps data in the internal buffer for a specific
2044     amount of time if the buffer is not full yet to decrease
2045     load on the usb bus.
2046
2047     \param ftdi pointer to ftdi_context
2048     \param latency Value between 1 and 255
2049
2050     \retval  0: all fine
2051     \retval -1: latency out of range
2052     \retval -2: unable to set latency timer
2053     \retval -3: USB device unavailable
2054 */
2055 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
2056 {
2057     unsigned short usb_val;
2058
2059     if (latency < 1)
2060         ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
2061
2062     if (ftdi == NULL || ftdi->usb_dev == NULL)
2063         ftdi_error_return(-3, "USB device unavailable");
2064
2065     usb_val = latency;
2066     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2067         ftdi_error_return(-2, "unable to set latency timer");
2068
2069     return 0;
2070 }
2071
2072 /**
2073     Get latency timer
2074
2075     \param ftdi pointer to ftdi_context
2076     \param latency Pointer to store latency value in
2077
2078     \retval  0: all fine
2079     \retval -1: unable to get latency timer
2080     \retval -2: USB device unavailable
2081 */
2082 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
2083 {
2084     unsigned short usb_val;
2085
2086     if (ftdi == NULL || ftdi->usb_dev == NULL)
2087         ftdi_error_return(-2, "USB device unavailable");
2088
2089     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (unsigned char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
2090         ftdi_error_return(-1, "reading latency timer failed");
2091
2092     *latency = (unsigned char)usb_val;
2093     return 0;
2094 }
2095
2096 /**
2097     Poll modem status information
2098
2099     This function allows the retrieve the two status bytes of the device.
2100     The device sends these bytes also as a header for each read access
2101     where they are discarded by ftdi_read_data(). The chip generates
2102     the two stripped status bytes in the absence of data every 40 ms.
2103
2104     Layout of the first byte:
2105     - B0..B3 - must be 0
2106     - B4       Clear to send (CTS)
2107                  0 = inactive
2108                  1 = active
2109     - B5       Data set ready (DTS)
2110                  0 = inactive
2111                  1 = active
2112     - B6       Ring indicator (RI)
2113                  0 = inactive
2114                  1 = active
2115     - B7       Receive line signal detect (RLSD)
2116                  0 = inactive
2117                  1 = active
2118
2119     Layout of the second byte:
2120     - B0       Data ready (DR)
2121     - B1       Overrun error (OE)
2122     - B2       Parity error (PE)
2123     - B3       Framing error (FE)
2124     - B4       Break interrupt (BI)
2125     - B5       Transmitter holding register (THRE)
2126     - B6       Transmitter empty (TEMT)
2127     - B7       Error in RCVR FIFO
2128
2129     \param ftdi pointer to ftdi_context
2130     \param status Pointer to store status information in. Must be two bytes.
2131
2132     \retval  0: all fine
2133     \retval -1: unable to retrieve status information
2134     \retval -2: USB device unavailable
2135 */
2136 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
2137 {
2138     char usb_val[2];
2139
2140     if (ftdi == NULL || ftdi->usb_dev == NULL)
2141         ftdi_error_return(-2, "USB device unavailable");
2142
2143     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, (unsigned char *)usb_val, 2, ftdi->usb_read_timeout) != 2)
2144         ftdi_error_return(-1, "getting modem status failed");
2145
2146     *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2147
2148     return 0;
2149 }
2150
2151 /**
2152     Set flowcontrol for ftdi chip
2153
2154     \param ftdi pointer to ftdi_context
2155     \param flowctrl flow control to use. should be
2156            SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
2157
2158     \retval  0: all fine
2159     \retval -1: set flow control failed
2160     \retval -2: USB device unavailable
2161 */
2162 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2163 {
2164     if (ftdi == NULL || ftdi->usb_dev == NULL)
2165         ftdi_error_return(-2, "USB device unavailable");
2166
2167     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2168                                 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2169                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2170         ftdi_error_return(-1, "set flow control failed");
2171
2172     return 0;
2173 }
2174
2175 /**
2176     Set dtr line
2177
2178     \param ftdi pointer to ftdi_context
2179     \param state state to set line to (1 or 0)
2180
2181     \retval  0: all fine
2182     \retval -1: set dtr failed
2183     \retval -2: USB device unavailable
2184 */
2185 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2186 {
2187     unsigned short usb_val;
2188
2189     if (ftdi == NULL || ftdi->usb_dev == NULL)
2190         ftdi_error_return(-2, "USB device unavailable");
2191
2192     if (state)
2193         usb_val = SIO_SET_DTR_HIGH;
2194     else
2195         usb_val = SIO_SET_DTR_LOW;
2196
2197     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2198                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2199                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2200         ftdi_error_return(-1, "set dtr failed");
2201
2202     return 0;
2203 }
2204
2205 /**
2206     Set rts line
2207
2208     \param ftdi pointer to ftdi_context
2209     \param state state to set line to (1 or 0)
2210
2211     \retval  0: all fine
2212     \retval -1: set rts failed
2213     \retval -2: USB device unavailable
2214 */
2215 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2216 {
2217     unsigned short usb_val;
2218
2219     if (ftdi == NULL || ftdi->usb_dev == NULL)
2220         ftdi_error_return(-2, "USB device unavailable");
2221
2222     if (state)
2223         usb_val = SIO_SET_RTS_HIGH;
2224     else
2225         usb_val = SIO_SET_RTS_LOW;
2226
2227     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2228                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2229                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2230         ftdi_error_return(-1, "set of rts failed");
2231
2232     return 0;
2233 }
2234
2235 /**
2236     Set dtr and rts line in one pass
2237
2238     \param ftdi pointer to ftdi_context
2239     \param dtr  DTR state to set line to (1 or 0)
2240     \param rts  RTS state to set line to (1 or 0)
2241
2242     \retval  0: all fine
2243     \retval -1: set dtr/rts failed
2244     \retval -2: USB device unavailable
2245  */
2246 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2247 {
2248     unsigned short usb_val;
2249
2250     if (ftdi == NULL || ftdi->usb_dev == NULL)
2251         ftdi_error_return(-2, "USB device unavailable");
2252
2253     if (dtr)
2254         usb_val = SIO_SET_DTR_HIGH;
2255     else
2256         usb_val = SIO_SET_DTR_LOW;
2257
2258     if (rts)
2259         usb_val |= SIO_SET_RTS_HIGH;
2260     else
2261         usb_val |= SIO_SET_RTS_LOW;
2262
2263     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2264                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2265                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2266         ftdi_error_return(-1, "set of rts/dtr failed");
2267
2268     return 0;
2269 }
2270
2271 /**
2272     Set the special event character
2273
2274     \param ftdi pointer to ftdi_context
2275     \param eventch Event character
2276     \param enable 0 to disable the event character, non-zero otherwise
2277
2278     \retval  0: all fine
2279     \retval -1: unable to set event character
2280     \retval -2: USB device unavailable
2281 */
2282 int ftdi_set_event_char(struct ftdi_context *ftdi,
2283                         unsigned char eventch, unsigned char enable)
2284 {
2285     unsigned short usb_val;
2286
2287     if (ftdi == NULL || ftdi->usb_dev == NULL)
2288         ftdi_error_return(-2, "USB device unavailable");
2289
2290     usb_val = eventch;
2291     if (enable)
2292         usb_val |= 1 << 8;
2293
2294     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2295         ftdi_error_return(-1, "setting event character failed");
2296
2297     return 0;
2298 }
2299
2300 /**
2301     Set error character
2302
2303     \param ftdi pointer to ftdi_context
2304     \param errorch Error character
2305     \param enable 0 to disable the error character, non-zero otherwise
2306
2307     \retval  0: all fine
2308     \retval -1: unable to set error character
2309     \retval -2: USB device unavailable
2310 */
2311 int ftdi_set_error_char(struct ftdi_context *ftdi,
2312                         unsigned char errorch, unsigned char enable)
2313 {
2314     unsigned short usb_val;
2315
2316     if (ftdi == NULL || ftdi->usb_dev == NULL)
2317         ftdi_error_return(-2, "USB device unavailable");
2318
2319     usb_val = errorch;
2320     if (enable)
2321         usb_val |= 1 << 8;
2322
2323     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2324         ftdi_error_return(-1, "setting error character failed");
2325
2326     return 0;
2327 }
2328
2329 /**
2330     Init eeprom with default values for the connected device
2331     \param ftdi pointer to ftdi_context
2332     \param manufacturer String to use as Manufacturer
2333     \param product String to use as Product description
2334     \param serial String to use as Serial number description
2335
2336     \retval  0: all fine
2337     \retval -1: No struct ftdi_context
2338     \retval -2: No struct ftdi_eeprom
2339     \retval -3: No connected device or device not yet opened
2340 */
2341 int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2342                              char * product, char * serial)
2343 {
2344     struct ftdi_eeprom *eeprom;
2345
2346     if (ftdi == NULL)
2347         ftdi_error_return(-1, "No struct ftdi_context");
2348
2349     if (ftdi->eeprom == NULL)
2350         ftdi_error_return(-2,"No struct ftdi_eeprom");
2351
2352     eeprom = ftdi->eeprom;
2353     memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2354
2355     if (ftdi->usb_dev == NULL)
2356         ftdi_error_return(-3, "No connected device or device not yet opened");
2357
2358     eeprom->vendor_id = 0x0403;
2359     eeprom->use_serial = 1;
2360     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2361             (ftdi->type == TYPE_R))
2362         eeprom->product_id = 0x6001;
2363     else if (ftdi->type == TYPE_4232H)
2364         eeprom->product_id = 0x6011;
2365     else if (ftdi->type == TYPE_232H)
2366         eeprom->product_id = 0x6014;
2367     else if (ftdi->type == TYPE_230X)
2368         eeprom->product_id = 0x6015;
2369     else
2370         eeprom->product_id = 0x6010;
2371
2372     if (ftdi->type == TYPE_AM)
2373         eeprom->usb_version = 0x0101;
2374     else
2375         eeprom->usb_version = 0x0200;
2376     eeprom->max_power = 100;
2377
2378     if (eeprom->manufacturer)
2379         free (eeprom->manufacturer);
2380     eeprom->manufacturer = NULL;
2381     if (manufacturer)
2382     {
2383         eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2384         if (eeprom->manufacturer)
2385             strcpy(eeprom->manufacturer, manufacturer);
2386     }
2387
2388     if (eeprom->product)
2389         free (eeprom->product);
2390     eeprom->product = NULL;
2391     if(product)
2392     {
2393         eeprom->product = malloc(strlen(product)+1);
2394         if (eeprom->product)
2395             strcpy(eeprom->product, product);
2396     }
2397     else
2398     {
2399         const char* default_product;
2400         switch(ftdi->type)
2401         {
2402             case TYPE_AM:    default_product = "AM"; break;
2403             case TYPE_BM:    default_product = "BM"; break;
2404             case TYPE_2232C: default_product = "Dual RS232"; break;
2405             case TYPE_R:     default_product = "FT232R USB UART"; break;
2406             case TYPE_2232H: default_product = "Dual RS232-HS"; break;
2407             case TYPE_4232H: default_product = "FT4232H"; break;
2408             case TYPE_232H:  default_product = "Single-RS232-HS"; break;
2409             case TYPE_230X:  default_product = "FT230X Basic UART"; break;
2410             default:
2411                 ftdi_error_return(-3, "Unknown chip type");
2412         }
2413         eeprom->product = malloc(strlen(default_product) +1);
2414         if (eeprom->product)
2415             strcpy(eeprom->product, default_product);
2416     }
2417
2418     if (eeprom->serial)
2419         free (eeprom->serial);
2420     eeprom->serial = NULL;
2421     if (serial)
2422     {
2423         eeprom->serial = malloc(strlen(serial)+1);
2424         if (eeprom->serial)
2425             strcpy(eeprom->serial, serial);
2426     }
2427
2428     if (ftdi->type == TYPE_R)
2429     {
2430         eeprom->max_power = 90;
2431         eeprom->size = 0x80;
2432         eeprom->cbus_function[0] = CBUS_TXLED;
2433         eeprom->cbus_function[1] = CBUS_RXLED;
2434         eeprom->cbus_function[2] = CBUS_TXDEN;
2435         eeprom->cbus_function[3] = CBUS_PWREN;
2436         eeprom->cbus_function[4] = CBUS_SLEEP;
2437     }
2438     else if (ftdi->type == TYPE_230X)
2439     {
2440         eeprom->max_power = 90;
2441         eeprom->size = 0x100;
2442         eeprom->cbus_function[0] = CBUSX_TXDEN;
2443         eeprom->cbus_function[1] = CBUSX_RXLED;
2444         eeprom->cbus_function[2] = CBUSX_TXLED;
2445         eeprom->cbus_function[3] = CBUSX_SLEEP;
2446     }
2447     else
2448     {
2449         if(ftdi->type == TYPE_232H)
2450         {
2451             int i;
2452             for (i=0; i<10; i++)
2453                 eeprom->cbus_function[i] = CBUSH_TRISTATE;
2454         }
2455         eeprom->size = -1;
2456     }
2457     switch (ftdi->type)
2458     {
2459         case TYPE_AM:
2460             eeprom->release_number = 0x0200;
2461             break;
2462         case TYPE_BM:
2463             eeprom->release_number = 0x0400;
2464             break;
2465         case TYPE_2232C:
2466             eeprom->release_number = 0x0500;
2467             break;
2468         case TYPE_R:
2469             eeprom->release_number = 0x0600;
2470             break;
2471         case TYPE_2232H:
2472             eeprom->release_number = 0x0700;
2473             break;
2474         case TYPE_4232H:
2475             eeprom->release_number = 0x0800;
2476             break;
2477         case TYPE_232H:
2478             eeprom->release_number = 0x0900;
2479             break;
2480         case TYPE_230X:
2481             eeprom->release_number = 0x1000;
2482             break;
2483         default:
2484             eeprom->release_number = 0x00;
2485     }
2486     return 0;
2487 }
2488
2489 int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char * manufacturer,
2490                             char * product, char * serial)
2491 {
2492     struct ftdi_eeprom *eeprom;
2493
2494     if (ftdi == NULL)
2495         ftdi_error_return(-1, "No struct ftdi_context");
2496
2497     if (ftdi->eeprom == NULL)
2498         ftdi_error_return(-2,"No struct ftdi_eeprom");
2499
2500     eeprom = ftdi->eeprom;
2501
2502     if (ftdi->usb_dev == NULL)
2503         ftdi_error_return(-3, "No connected device or device not yet opened");
2504
2505     if (manufacturer)
2506     {
2507         if (eeprom->manufacturer)
2508             free (eeprom->manufacturer);
2509         eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2510         if (eeprom->manufacturer)
2511             strcpy(eeprom->manufacturer, manufacturer);
2512     }
2513
2514     if(product)
2515     {
2516         if (eeprom->product)
2517             free (eeprom->product);
2518         eeprom->product = malloc(strlen(product)+1);
2519         if (eeprom->product)
2520             strcpy(eeprom->product, product);
2521     }
2522
2523     if (serial)
2524     {
2525         if (eeprom->serial)
2526             free (eeprom->serial);
2527         eeprom->serial = malloc(strlen(serial)+1);
2528         if (eeprom->serial)
2529         {
2530             strcpy(eeprom->serial, serial);
2531             eeprom->use_serial = 1;
2532         }
2533     }
2534     return 0;
2535 }
2536
2537
2538 /*FTD2XX doesn't check for values not fitting in the ACBUS Signal options*/
2539 void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2540 {
2541     int i;
2542     for(i=0; i<5; i++)
2543     {
2544         int mode_low, mode_high;
2545         if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2546             mode_low = CBUSH_TRISTATE;
2547         else
2548             mode_low = eeprom->cbus_function[2*i];
2549         if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2550             mode_high = CBUSH_TRISTATE;
2551         else
2552             mode_high = eeprom->cbus_function[2*i+1];
2553
2554         output[0x18+i] = (mode_high <<4) | mode_low;
2555     }
2556 }
2557 /* Return the bits for the encoded EEPROM Structure of a requested Mode
2558  *
2559  */
2560 static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip)
2561 {
2562     switch (chip)
2563     {
2564         case TYPE_2232H:
2565         case TYPE_2232C:
2566         {
2567             switch (type)
2568             {
2569                 case CHANNEL_IS_UART: return 0;
2570                 case CHANNEL_IS_FIFO: return 0x01;
2571                 case CHANNEL_IS_OPTO: return 0x02;
2572                 case CHANNEL_IS_CPU : return 0x04;
2573                 default: return 0;
2574             }
2575         }
2576         case TYPE_232H:
2577         {
2578             switch (type)
2579             {
2580                 case CHANNEL_IS_UART   : return 0;
2581                 case CHANNEL_IS_FIFO   : return 0x01;
2582                 case CHANNEL_IS_OPTO   : return 0x02;
2583                 case CHANNEL_IS_CPU    : return 0x04;
2584                 case CHANNEL_IS_FT1284 : return 0x08;
2585                 default: return 0;
2586             }
2587         }
2588         case TYPE_230X: /* FT230X is only UART */
2589         default: return 0;
2590     }
2591     return 0;
2592 }
2593
2594 /**
2595     Build binary buffer from ftdi_eeprom structure.
2596     Output is suitable for ftdi_write_eeprom().
2597
2598     \param ftdi pointer to ftdi_context
2599
2600     \retval >=0: size of eeprom user area in bytes
2601     \retval -1: eeprom size (128 bytes) exceeded by custom strings
2602     \retval -2: Invalid eeprom or ftdi pointer
2603     \retval -3: Invalid cbus function setting     (FIXME: Not in the code?)
2604     \retval -4: Chip doesn't support invert       (FIXME: Not in the code?)
2605     \retval -5: Chip doesn't support high current drive         (FIXME: Not in the code?)
2606     \retval -6: No connected EEPROM or EEPROM Type unknown
2607 */
2608 int ftdi_eeprom_build(struct ftdi_context *ftdi)
2609 {
2610     unsigned char i, j, eeprom_size_mask;
2611     unsigned short checksum, value;
2612     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2613     int user_area_size, free_start, free_end;
2614     struct ftdi_eeprom *eeprom;
2615     unsigned char * output;
2616
2617     if (ftdi == NULL)
2618         ftdi_error_return(-2,"No context");
2619     if (ftdi->eeprom == NULL)
2620         ftdi_error_return(-2,"No eeprom structure");
2621
2622     eeprom= ftdi->eeprom;
2623     output = eeprom->buf;
2624
2625     if (eeprom->chip == -1)
2626         ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2627
2628     if (eeprom->size == -1)
2629     {
2630         if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2631             eeprom->size = 0x100;
2632         else
2633             eeprom->size = 0x80;
2634     }
2635
2636     if (eeprom->manufacturer != NULL)
2637         manufacturer_size = strlen(eeprom->manufacturer);
2638     if (eeprom->product != NULL)
2639         product_size = strlen(eeprom->product);
2640     if (eeprom->serial != NULL)
2641         serial_size = strlen(eeprom->serial);
2642
2643     // eeprom size check
2644     switch (ftdi->type)
2645     {
2646         case TYPE_AM:
2647         case TYPE_BM:
2648         case TYPE_R:
2649             user_area_size = 96;    // base size for strings (total of 48 characters)
2650             break;
2651         case TYPE_2232C:
2652             user_area_size = 90;     // two extra config bytes and 4 bytes PnP stuff
2653             break;
2654         case TYPE_230X:
2655             user_area_size = 88;     // four extra config bytes + 4 bytes PnP stuff
2656             break;
2657         case TYPE_2232H:            // six extra config bytes + 4 bytes PnP stuff
2658         case TYPE_4232H:
2659             user_area_size = 86;
2660             break;
2661         case TYPE_232H:
2662             user_area_size = 80;
2663             break;
2664         default:
2665             user_area_size = 0;
2666             break;
2667     }
2668     user_area_size  -= (manufacturer_size + product_size + serial_size) * 2;
2669
2670     if (user_area_size < 0)
2671         ftdi_error_return(-1,"eeprom size exceeded");
2672
2673     // empty eeprom
2674     if (ftdi->type == TYPE_230X)
2675     {
2676         /* FT230X have a reserved section in the middle of the MTP,
2677            which cannot be written to, but must be included in the checksum */
2678         memset(ftdi->eeprom->buf, 0, 0x80);
2679         memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0));
2680     }
2681     else
2682     {
2683         memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2684     }
2685
2686     // Bytes and Bits set for all Types
2687
2688     // Addr 02: Vendor ID
2689     output[0x02] = eeprom->vendor_id;
2690     output[0x03] = eeprom->vendor_id >> 8;
2691
2692     // Addr 04: Product ID
2693     output[0x04] = eeprom->product_id;
2694     output[0x05] = eeprom->product_id >> 8;
2695
2696     // Addr 06: Device release number (0400h for BM features)
2697     output[0x06] = eeprom->release_number;
2698     output[0x07] = eeprom->release_number >> 8;
2699
2700     // Addr 08: Config descriptor
2701     // Bit 7: always 1
2702     // Bit 6: 1 if this device is self powered, 0 if bus powered
2703     // Bit 5: 1 if this device uses remote wakeup
2704     // Bit 4-0: reserved - 0
2705     j = 0x80;
2706     if (eeprom->self_powered)
2707         j |= 0x40;
2708     if (eeprom->remote_wakeup)
2709         j |= 0x20;
2710     output[0x08] = j;
2711
2712     // Addr 09: Max power consumption: max power = value * 2 mA
2713     output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT;
2714
2715     if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X))
2716     {
2717         // Addr 0A: Chip configuration
2718         // Bit 7: 0 - reserved
2719         // Bit 6: 0 - reserved
2720         // Bit 5: 0 - reserved
2721         // Bit 4: 1 - Change USB version
2722         // Bit 3: 1 - Use the serial number string
2723         // Bit 2: 1 - Enable suspend pull downs for lower power
2724         // Bit 1: 1 - Out EndPoint is Isochronous
2725         // Bit 0: 1 - In EndPoint is Isochronous
2726         //
2727         j = 0;
2728         if (eeprom->in_is_isochronous)
2729             j = j | 1;
2730         if (eeprom->out_is_isochronous)
2731             j = j | 2;
2732         output[0x0A] = j;
2733     }
2734
2735     // Dynamic content
2736     // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2737     // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2738     // 0xa0 (TYPE_232H)
2739     i = 0;
2740     switch (ftdi->type)
2741     {
2742         case TYPE_2232H:
2743         case TYPE_4232H:
2744             i += 2;
2745         case TYPE_R:
2746             i += 2;
2747         case TYPE_2232C:
2748             i += 2;
2749         case TYPE_AM:
2750         case TYPE_BM:
2751             i += 0x94;
2752             break;
2753         case TYPE_232H:
2754         case TYPE_230X:
2755             i = 0xa0;
2756             break;
2757     }
2758     /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2759     eeprom_size_mask = eeprom->size -1;
2760     free_end = i & eeprom_size_mask;
2761
2762     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2763     // Addr 0F: Length of manufacturer string
2764     // Output manufacturer
2765     output[0x0E] = i;  // calculate offset
2766     output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2767     output[i & eeprom_size_mask] = 0x03, i++; // type: string
2768     for (j = 0; j < manufacturer_size; j++)
2769     {
2770         output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2771         output[i & eeprom_size_mask] = 0x00, i++;
2772     }
2773     output[0x0F] = manufacturer_size*2 + 2;
2774
2775     // Addr 10: Offset of the product string + 0x80, calculated later
2776     // Addr 11: Length of product string
2777     output[0x10] = i | 0x80;  // calculate offset
2778     output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2779     output[i & eeprom_size_mask] = 0x03, i++;
2780     for (j = 0; j < product_size; j++)
2781     {
2782         output[i & eeprom_size_mask] = eeprom->product[j], i++;
2783         output[i & eeprom_size_mask] = 0x00, i++;
2784     }
2785     output[0x11] = product_size*2 + 2;
2786
2787     // Addr 12: Offset of the serial string + 0x80, calculated later
2788     // Addr 13: Length of serial string
2789     output[0x12] = i | 0x80; // calculate offset
2790     output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2791     output[i & eeprom_size_mask] = 0x03, i++;
2792     for (j = 0; j < serial_size; j++)
2793     {
2794         output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2795         output[i & eeprom_size_mask] = 0x00, i++;
2796     }
2797
2798     // Legacy port name and PnP fields for FT2232 and newer chips
2799     if (ftdi->type > TYPE_BM)
2800     {
2801         output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2802         i++;
2803         output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2804         i++;
2805         output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2806         i++;
2807     }
2808
2809     output[0x13] = serial_size*2 + 2;
2810
2811     if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2812     {
2813         if (eeprom->use_serial)
2814             output[0x0A] |= USE_SERIAL_NUM;
2815         else
2816             output[0x0A] &= ~USE_SERIAL_NUM;
2817     }
2818
2819     /* Bytes and Bits specific to (some) types
2820        Write linear, as this allows easier fixing*/
2821     switch (ftdi->type)
2822     {
2823         case TYPE_AM:
2824             break;
2825         case TYPE_BM:
2826             output[0x0C] = eeprom->usb_version & 0xff;
2827             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2828             if (eeprom->use_usb_version)
2829                 output[0x0A] |= USE_USB_VERSION_BIT;
2830             else
2831                 output[0x0A] &= ~USE_USB_VERSION_BIT;
2832
2833             break;
2834         case TYPE_2232C:
2835
2836             output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C);
2837             if ( eeprom->channel_a_driver == DRIVER_VCP)
2838                 output[0x00] |= DRIVER_VCP;
2839             else
2840                 output[0x00] &= ~DRIVER_VCP;
2841
2842             if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2843                 output[0x00] |= HIGH_CURRENT_DRIVE;
2844             else
2845                 output[0x00] &= ~HIGH_CURRENT_DRIVE;
2846
2847             output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C);
2848             if ( eeprom->channel_b_driver == DRIVER_VCP)
2849                 output[0x01] |= DRIVER_VCP;
2850             else
2851                 output[0x01] &= ~DRIVER_VCP;
2852
2853             if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2854                 output[0x01] |= HIGH_CURRENT_DRIVE;
2855             else
2856                 output[0x01] &= ~HIGH_CURRENT_DRIVE;
2857
2858             if (eeprom->in_is_isochronous)
2859                 output[0x0A] |= 0x1;
2860             else
2861                 output[0x0A] &= ~0x1;
2862             if (eeprom->out_is_isochronous)
2863                 output[0x0A] |= 0x2;
2864             else
2865                 output[0x0A] &= ~0x2;
2866             if (eeprom->suspend_pull_downs)
2867                 output[0x0A] |= 0x4;
2868             else
2869                 output[0x0A] &= ~0x4;
2870             if (eeprom->use_usb_version)
2871                 output[0x0A] |= USE_USB_VERSION_BIT;
2872             else
2873                 output[0x0A] &= ~USE_USB_VERSION_BIT;
2874
2875             output[0x0C] = eeprom->usb_version & 0xff;
2876             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2877             output[0x14] = eeprom->chip;
2878             break;
2879         case TYPE_R:
2880             if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2881                 output[0x00] |= HIGH_CURRENT_DRIVE_R;
2882             if (eeprom->external_oscillator)
2883                 output[0x00] |= 0x02;
2884             output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2885
2886             if (eeprom->suspend_pull_downs)
2887                 output[0x0A] |= 0x4;
2888             else
2889                 output[0x0A] &= ~0x4;
2890             output[0x0B] = eeprom->invert;
2891             output[0x0C] = eeprom->usb_version & 0xff;
2892             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2893
2894             if (eeprom->cbus_function[0] > CBUS_BB_RD)
2895                 output[0x14] = CBUS_TXLED;
2896             else
2897                 output[0x14] = eeprom->cbus_function[0];
2898
2899             if (eeprom->cbus_function[1] > CBUS_BB_RD)
2900                 output[0x14] |= CBUS_RXLED<<4;
2901             else
2902                 output[0x14] |= eeprom->cbus_function[1]<<4;
2903
2904             if (eeprom->cbus_function[2] > CBUS_BB_RD)
2905                 output[0x15] = CBUS_TXDEN;
2906             else
2907                 output[0x15] = eeprom->cbus_function[2];
2908
2909             if (eeprom->cbus_function[3] > CBUS_BB_RD)
2910                 output[0x15] |= CBUS_PWREN<<4;
2911             else
2912                 output[0x15] |= eeprom->cbus_function[3]<<4;
2913
2914             if (eeprom->cbus_function[4] > CBUS_CLK6)
2915                 output[0x16] = CBUS_SLEEP;
2916             else
2917                 output[0x16] = eeprom->cbus_function[4];
2918             break;
2919         case TYPE_2232H:
2920             output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H);
2921             if ( eeprom->channel_a_driver == DRIVER_VCP)
2922                 output[0x00] |= DRIVER_VCP;
2923             else
2924                 output[0x00] &= ~DRIVER_VCP;
2925
2926             output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H);
2927             if ( eeprom->channel_b_driver == DRIVER_VCP)
2928                 output[0x01] |= DRIVER_VCP;
2929             else
2930                 output[0x01] &= ~DRIVER_VCP;
2931             if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2932                 output[0x01] |= SUSPEND_DBUS7_BIT;
2933             else
2934                 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2935
2936             if (eeprom->suspend_pull_downs)
2937                 output[0x0A] |= 0x4;
2938             else
2939                 output[0x0A] &= ~0x4;
2940
2941             if (eeprom->group0_drive > DRIVE_16MA)
2942                 output[0x0c] |= DRIVE_16MA;
2943             else
2944                 output[0x0c] |= eeprom->group0_drive;
2945             if (eeprom->group0_schmitt == IS_SCHMITT)
2946                 output[0x0c] |= IS_SCHMITT;
2947             if (eeprom->group0_slew == SLOW_SLEW)
2948                 output[0x0c] |= SLOW_SLEW;
2949
2950             if (eeprom->group1_drive > DRIVE_16MA)
2951                 output[0x0c] |= DRIVE_16MA<<4;
2952             else
2953                 output[0x0c] |= eeprom->group1_drive<<4;
2954             if (eeprom->group1_schmitt == IS_SCHMITT)
2955                 output[0x0c] |= IS_SCHMITT<<4;
2956             if (eeprom->group1_slew == SLOW_SLEW)
2957                 output[0x0c] |= SLOW_SLEW<<4;
2958
2959             if (eeprom->group2_drive > DRIVE_16MA)
2960                 output[0x0d] |= DRIVE_16MA;
2961             else
2962                 output[0x0d] |= eeprom->group2_drive;
2963             if (eeprom->group2_schmitt == IS_SCHMITT)
2964                 output[0x0d] |= IS_SCHMITT;
2965             if (eeprom->group2_slew == SLOW_SLEW)
2966                 output[0x0d] |= SLOW_SLEW;
2967
2968             if (eeprom->group3_drive > DRIVE_16MA)
2969                 output[0x0d] |= DRIVE_16MA<<4;
2970             else
2971                 output[0x0d] |= eeprom->group3_drive<<4;
2972             if (eeprom->group3_schmitt == IS_SCHMITT)
2973                 output[0x0d] |= IS_SCHMITT<<4;
2974             if (eeprom->group3_slew == SLOW_SLEW)
2975                 output[0x0d] |= SLOW_SLEW<<4;
2976
2977             output[0x18] = eeprom->chip;
2978
2979             break;
2980         case TYPE_4232H:
2981             if (eeprom->channel_a_driver == DRIVER_VCP)
2982                 output[0x00] |= DRIVER_VCP;
2983             else
2984                 output[0x00] &= ~DRIVER_VCP;
2985             if (eeprom->channel_b_driver == DRIVER_VCP)
2986                 output[0x01] |= DRIVER_VCP;
2987             else
2988                 output[0x01] &= ~DRIVER_VCP;
2989             if (eeprom->channel_c_driver == DRIVER_VCP)
2990                 output[0x00] |= (DRIVER_VCP << 4);
2991             else
2992                 output[0x00] &= ~(DRIVER_VCP << 4);
2993             if (eeprom->channel_d_driver == DRIVER_VCP)
2994                 output[0x01] |= (DRIVER_VCP << 4);
2995             else
2996                 output[0x01] &= ~(DRIVER_VCP << 4);
2997
2998             if (eeprom->suspend_pull_downs)
2999                 output[0x0a] |= 0x4;
3000             else
3001                 output[0x0a] &= ~0x4;
3002
3003             if (eeprom->channel_a_rs485enable)
3004                 output[0x0b] |= CHANNEL_IS_RS485 << 0;
3005             else
3006                 output[0x0b] &= ~(CHANNEL_IS_RS485 << 0);
3007             if (eeprom->channel_b_rs485enable)
3008                 output[0x0b] |= CHANNEL_IS_RS485 << 1;
3009             else
3010                 output[0x0b] &= ~(CHANNEL_IS_RS485 << 1);
3011             if (eeprom->channel_c_rs485enable)
3012                 output[0x0b] |= CHANNEL_IS_RS485 << 2;
3013             else
3014                 output[0x0b] &= ~(CHANNEL_IS_RS485 << 2);
3015             if (eeprom->channel_d_rs485enable)
3016                 output[0x0b] |= CHANNEL_IS_RS485 << 3;
3017             else
3018                 output[0x0b] &= ~(CHANNEL_IS_RS485 << 3);
3019
3020             if (eeprom->group0_drive > DRIVE_16MA)
3021                 output[0x0c] |= DRIVE_16MA;
3022             else
3023                 output[0x0c] |= eeprom->group0_drive;
3024             if (eeprom->group0_schmitt == IS_SCHMITT)
3025                 output[0x0c] |= IS_SCHMITT;
3026             if (eeprom->group0_slew == SLOW_SLEW)
3027                 output[0x0c] |= SLOW_SLEW;
3028
3029             if (eeprom->group1_drive > DRIVE_16MA)
3030                 output[0x0c] |= DRIVE_16MA<<4;
3031             else
3032                 output[0x0c] |= eeprom->group1_drive<<4;
3033             if (eeprom->group1_schmitt == IS_SCHMITT)
3034                 output[0x0c] |= IS_SCHMITT<<4;
3035             if (eeprom->group1_slew == SLOW_SLEW)
3036                 output[0x0c] |= SLOW_SLEW<<4;
3037
3038             if (eeprom->group2_drive > DRIVE_16MA)
3039                 output[0x0d] |= DRIVE_16MA;
3040             else
3041                 output[0x0d] |= eeprom->group2_drive;
3042             if (eeprom->group2_schmitt == IS_SCHMITT)
3043                 output[0x0d] |= IS_SCHMITT;
3044             if (eeprom->group2_slew == SLOW_SLEW)
3045                 output[0x0d] |= SLOW_SLEW;
3046
3047             if (eeprom->group3_drive > DRIVE_16MA)
3048                 output[0x0d] |= DRIVE_16MA<<4;
3049             else
3050                 output[0x0d] |= eeprom->group3_drive<<4;
3051             if (eeprom->group3_schmitt == IS_SCHMITT)
3052                 output[0x0d] |= IS_SCHMITT<<4;
3053             if (eeprom->group3_slew == SLOW_SLEW)
3054                 output[0x0d] |= SLOW_SLEW<<4;
3055
3056             output[0x18] = eeprom->chip;
3057
3058             break;
3059         case TYPE_232H:
3060             output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H);
3061             if ( eeprom->channel_a_driver == DRIVER_VCP)
3062                 output[0x00] |= DRIVER_VCPH;
3063             else
3064                 output[0x00] &= ~DRIVER_VCPH;
3065             if (eeprom->powersave)
3066                 output[0x01] |= POWER_SAVE_DISABLE_H;
3067             else
3068                 output[0x01] &= ~POWER_SAVE_DISABLE_H;
3069
3070             if (eeprom->suspend_pull_downs)
3071                 output[0x0a] |= 0x4;
3072             else
3073                 output[0x0a] &= ~0x4;
3074
3075             if (eeprom->clock_polarity)
3076                 output[0x01] |= FT1284_CLK_IDLE_STATE;
3077             else
3078                 output[0x01] &= ~FT1284_CLK_IDLE_STATE;
3079             if (eeprom->data_order)
3080                 output[0x01] |= FT1284_DATA_LSB;
3081             else
3082                 output[0x01] &= ~FT1284_DATA_LSB;
3083             if (eeprom->flow_control)
3084                 output[0x01] |= FT1284_FLOW_CONTROL;
3085             else
3086                 output[0x01] &= ~FT1284_FLOW_CONTROL;
3087             if (eeprom->group0_drive > DRIVE_16MA)
3088                 output[0x0c] |= DRIVE_16MA;
3089             else
3090                 output[0x0c] |= eeprom->group0_drive;
3091             if (eeprom->group0_schmitt == IS_SCHMITT)
3092                 output[0x0c] |= IS_SCHMITT;
3093             if (eeprom->group0_slew == SLOW_SLEW)
3094                 output[0x0c] |= SLOW_SLEW;
3095
3096             if (eeprom->group1_drive > DRIVE_16MA)
3097                 output[0x0d] |= DRIVE_16MA;
3098             else
3099                 output[0x0d] |= eeprom->group1_drive;
3100             if (eeprom->group1_schmitt == IS_SCHMITT)
3101                 output[0x0d] |= IS_SCHMITT;
3102             if (eeprom->group1_slew == SLOW_SLEW)
3103                 output[0x0d] |= SLOW_SLEW;
3104
3105             set_ft232h_cbus(eeprom, output);
3106
3107             output[0x1e] = eeprom->chip;
3108             fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
3109             break;
3110         case TYPE_230X:
3111             output[0x00] = 0x80; /* Actually, leave the default value */
3112             output[0x0a] = 0x08; /* Enable USB Serial Number */
3113             /*FIXME: Make DBUS & CBUS Control configurable*/
3114             output[0x0c] = 0;    /* DBUS drive 4mA, CBUS drive 4 mA like factory default */
3115             for (j = 0; j <= 6; j++)
3116             {
3117                 output[0x1a + j] = eeprom->cbus_function[j];
3118             }
3119             output[0x0b] = eeprom->invert;
3120             break;
3121     }
3122
3123     /* First address without use */
3124     free_start = 0;
3125     switch (ftdi->type)
3126     {
3127         case TYPE_230X:
3128             free_start += 2;
3129         case TYPE_232H:
3130             free_start += 6;
3131         case TYPE_2232H:
3132         case TYPE_4232H:
3133             free_start += 2;
3134         case TYPE_R:
3135             free_start += 2;
3136         case TYPE_2232C:
3137             free_start++;
3138         case TYPE_AM:
3139         case TYPE_BM:
3140             free_start += 0x14;
3141     }
3142
3143     /* Arbitrary user data */
3144     if (eeprom->user_data && eeprom->user_data_size >= 0)
3145     {
3146         if (eeprom->user_data_addr < free_start)
3147             fprintf(stderr,"Warning, user data starts inside the generated data!\n");
3148         if (eeprom->user_data_addr + eeprom->user_data_size >= free_end)
3149             fprintf(stderr,"Warning, user data overlaps the strings area!\n");
3150         if (eeprom->user_data_addr + eeprom->user_data_size > eeprom->size)
3151             ftdi_error_return(-1,"eeprom size exceeded");
3152         memcpy(output + eeprom->user_data_addr, eeprom->user_data, eeprom->user_data_size);
3153     }
3154
3155     // calculate checksum
3156     checksum = 0xAAAA;
3157
3158     for (i = 0; i < eeprom->size/2-1; i++)
3159     {
3160         if ((ftdi->type == TYPE_230X) && (i == 0x12))
3161         {
3162             /* FT230X has a user section in the MTP which is not part of the checksum */
3163             i = 0x40;
3164         }
3165         if ((ftdi->type == TYPE_230X) && (i >=  0x40) && (i < 0x50)) {
3166             uint16_t data;
3167             if (ftdi_read_eeprom_location(ftdi, i, &data)) {
3168                 fprintf(stderr, "Reading Factory Configuration Data failed\n");
3169                 i = 0x50;
3170             }
3171             value = data;
3172         }
3173         else {
3174             value = output[i*2];
3175             value += output[(i*2)+1] << 8;
3176         }
3177         checksum = value^checksum;
3178         checksum = (checksum << 1) | (checksum >> 15);
3179     }
3180
3181     output[eeprom->size-2] = checksum;
3182     output[eeprom->size-1] = checksum >> 8;
3183
3184     eeprom->initialized_for_connected_device = 1;
3185     return user_area_size;
3186 }
3187 /* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
3188  * EEPROM structure
3189  *
3190  * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
3191  */
3192 static unsigned char bit2type(unsigned char bits)
3193 {
3194     switch (bits)
3195     {
3196         case   0: return CHANNEL_IS_UART;
3197         case   1: return CHANNEL_IS_FIFO;
3198         case   2: return CHANNEL_IS_OPTO;
3199         case   4: return CHANNEL_IS_CPU;
3200         case   8: return CHANNEL_IS_FT1284;
3201         default:
3202             fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
3203                     bits);
3204     }
3205     return 0;
3206 }
3207 /* Decode 230X / 232R type chips invert bits
3208  * Prints directly to stdout.
3209 */
3210 static void print_inverted_bits(int invert)
3211 {
3212     char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"};
3213     int i;
3214
3215     fprintf(stdout,"Inverted bits:");
3216     for (i=0; i<8; i++)
3217         if ((invert & (1<<i)) == (1<<i))
3218             fprintf(stdout," %s",r_bits[i]);
3219
3220     fprintf(stdout,"\n");
3221 }
3222 /**
3223    Decode binary EEPROM image into an ftdi_eeprom structure.
3224
3225    For FT-X devices use AN_201 FT-X MTP memory Configuration to decode.
3226
3227    \param ftdi pointer to ftdi_context
3228    \param verbose Decode EEPROM on stdout
3229
3230    \retval 0: all fine
3231    \retval -1: something went wrong
3232
3233    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
3234    FIXME: Strings are malloc'ed here and should be freed somewhere
3235 */
3236 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
3237 {
3238     int i, j;
3239     unsigned short checksum, eeprom_checksum, value;
3240     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3241     int eeprom_size;
3242     struct ftdi_eeprom *eeprom;
3243     unsigned char *buf = NULL;
3244
3245     if (ftdi == NULL)
3246         ftdi_error_return(-1,"No context");
3247     if (ftdi->eeprom == NULL)
3248         ftdi_error_return(-1,"No eeprom structure");
3249
3250     eeprom = ftdi->eeprom;
3251     eeprom_size = eeprom->size;
3252     buf = ftdi->eeprom->buf;
3253
3254     // Addr 02: Vendor ID
3255     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
3256
3257     // Addr 04: Product ID
3258     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
3259
3260     // Addr 06: Device release number
3261     eeprom->release_number = buf[0x06] + (buf[0x07]<<8);
3262
3263     // Addr 08: Config descriptor
3264     // Bit 7: always 1
3265     // Bit 6: 1 if this device is self powered, 0 if bus powered
3266     // Bit 5: 1 if this device uses remote wakeup
3267     eeprom->self_powered = buf[0x08] & 0x40;
3268     eeprom->remote_wakeup = buf[0x08] & 0x20;
3269
3270     // Addr 09: Max power consumption: max power = value * 2 mA
3271     eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09];
3272
3273     // Addr 0A: Chip configuration
3274     // Bit 7: 0 - reserved
3275     // Bit 6: 0 - reserved
3276     // Bit 5: 0 - reserved
3277     // Bit 4: 1 - Change USB version on BM and 2232C
3278     // Bit 3: 1 - Use the serial number string
3279     // Bit 2: 1 - Enable suspend pull downs for lower power
3280     // Bit 1: 1 - Out EndPoint is Isochronous
3281     // Bit 0: 1 - In EndPoint is Isochronous
3282     //
3283     eeprom->in_is_isochronous  = buf[0x0A]&0x01;
3284     eeprom->out_is_isochronous = buf[0x0A]&0x02;
3285     eeprom->suspend_pull_downs = buf[0x0A]&0x04;
3286     eeprom->use_serial         = !!(buf[0x0A] & USE_SERIAL_NUM);
3287     eeprom->use_usb_version    = !!(buf[0x0A] & USE_USB_VERSION_BIT);
3288
3289     // Addr 0C: USB version low byte when 0x0A
3290     // Addr 0D: USB version high byte when 0x0A
3291     eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
3292
3293     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
3294     // Addr 0F: Length of manufacturer string
3295     manufacturer_size = buf[0x0F]/2;
3296     if (eeprom->manufacturer)
3297         free(eeprom->manufacturer);
3298     if (manufacturer_size > 0)
3299     {
3300         eeprom->manufacturer = malloc(manufacturer_size);
3301         if (eeprom->manufacturer)
3302         {
3303             // Decode manufacturer
3304             i = buf[0x0E] & (eeprom_size -1); // offset
3305             for (j=0; j<manufacturer_size-1; j++)
3306             {
3307                 eeprom->manufacturer[j] = buf[2*j+i+2];
3308             }
3309             eeprom->manufacturer[j] = '\0';
3310         }
3311     }
3312     else eeprom->manufacturer = NULL;
3313
3314     // Addr 10: Offset of the product string + 0x80, calculated later
3315     // Addr 11: Length of product string
3316     if (eeprom->product)
3317         free(eeprom->product);
3318     product_size = buf[0x11]/2;
3319     if (product_size > 0)
3320     {
3321         eeprom->product = malloc(product_size);
3322         if (eeprom->product)
3323         {
3324             // Decode product name
3325             i = buf[0x10] & (eeprom_size -1); // offset
3326             for (j=0; j<product_size-1; j++)
3327             {
3328                 eeprom->product[j] = buf[2*j+i+2];
3329             }
3330             eeprom->product[j] = '\0';
3331         }
3332     }
3333     else eeprom->product = NULL;
3334
3335     // Addr 12: Offset of the serial string + 0x80, calculated later
3336     // Addr 13: Length of serial string
3337     if (eeprom->serial)
3338         free(eeprom->serial);
3339     serial_size = buf[0x13]/2;
3340     if (serial_size > 0)
3341     {
3342         eeprom->serial = malloc(serial_size);
3343         if (eeprom->serial)
3344         {
3345             // Decode serial
3346             i = buf[0x12] & (eeprom_size -1); // offset
3347             for (j=0; j<serial_size-1; j++)
3348             {
3349                 eeprom->serial[j] = buf[2*j+i+2];
3350             }
3351             eeprom->serial[j] = '\0';
3352         }
3353     }
3354     else eeprom->serial = NULL;
3355
3356     // verify checksum
3357     checksum = 0xAAAA;
3358
3359     for (i = 0; i < eeprom_size/2-1; i++)
3360     {
3361         if ((ftdi->type == TYPE_230X) && (i == 0x12))
3362         {
3363             /* FT230X has a user section in the MTP which is not part of the checksum */
3364             i = 0x40;
3365         }
3366         value = buf[i*2];
3367         value += buf[(i*2)+1] << 8;
3368
3369         checksum = value^checksum;
3370         checksum = (checksum << 1) | (checksum >> 15);
3371     }
3372
3373     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3374
3375     if (eeprom_checksum != checksum)
3376     {
3377         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3378         ftdi_error_return(-1,"EEPROM checksum error");
3379     }
3380
3381     eeprom->channel_a_type   = 0;
3382     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
3383     {
3384         eeprom->chip = -1;
3385     }
3386     else if (ftdi->type == TYPE_2232C)
3387     {
3388         eeprom->channel_a_type   = bit2type(buf[0x00] & 0x7);
3389         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3390         eeprom->high_current_a   = buf[0x00] & HIGH_CURRENT_DRIVE;
3391         eeprom->channel_b_type   = buf[0x01] & 0x7;
3392         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3393         eeprom->high_current_b   = buf[0x01] & HIGH_CURRENT_DRIVE;
3394         eeprom->chip = buf[0x14];
3395     }
3396     else if (ftdi->type == TYPE_R)
3397     {
3398         /* TYPE_R flags D2XX, not VCP as all others*/
3399         eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
3400         eeprom->high_current     = buf[0x00] & HIGH_CURRENT_DRIVE_R;
3401         eeprom->external_oscillator = buf[0x00] & 0x02;
3402         if ( (buf[0x01]&0x40) != 0x40)
3403             fprintf(stderr,
3404                     "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
3405                     " If this happened with the\n"
3406                     " EEPROM programmed by FTDI tools, please report "
3407                     "to libftdi@developer.intra2net.com\n");
3408
3409         eeprom->chip = buf[0x16];
3410         // Addr 0B: Invert data lines
3411         // Works only on FT232R, not FT245R, but no way to distinguish
3412         eeprom->invert = buf[0x0B];
3413         // Addr 14: CBUS function: CBUS0, CBUS1
3414         // Addr 15: CBUS function: CBUS2, CBUS3
3415         // Addr 16: CBUS function: CBUS5
3416         eeprom->cbus_function[0] = buf[0x14] & 0x0f;
3417         eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
3418         eeprom->cbus_function[2] = buf[0x15] & 0x0f;
3419         eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
3420         eeprom->cbus_function[4] = buf[0x16] & 0x0f;
3421     }
3422     else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3423     {
3424         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3425         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3426
3427         if (ftdi->type == TYPE_2232H)
3428         {
3429             eeprom->channel_a_type   = bit2type(buf[0x00] & 0x7);
3430             eeprom->channel_b_type   = bit2type(buf[0x01] & 0x7);
3431             eeprom->suspend_dbus7    = buf[0x01] & SUSPEND_DBUS7_BIT;
3432         }
3433         else
3434         {
3435             eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP;
3436             eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP;
3437             eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0);
3438             eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1);
3439             eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2);
3440             eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3);
3441         }
3442
3443         eeprom->chip = buf[0x18];
3444         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
3445         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3446         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3447         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x3;
3448         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3449         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
3450         eeprom->group2_drive   =  buf[0x0d]       & DRIVE_16MA;
3451         eeprom->group2_schmitt =  buf[0x0d]       & IS_SCHMITT;
3452         eeprom->group2_slew    =  buf[0x0d]       & SLOW_SLEW;
3453         eeprom->group3_drive   = (buf[0x0d] >> 4) & DRIVE_16MA;
3454         eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3455         eeprom->group3_slew    = (buf[0x0d] >> 4) & SLOW_SLEW;
3456     }
3457     else if (ftdi->type == TYPE_232H)
3458     {
3459         eeprom->channel_a_type   = buf[0x00] & 0xf;
3460         eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
3461         eeprom->clock_polarity =  buf[0x01]       & FT1284_CLK_IDLE_STATE;
3462         eeprom->data_order     =  buf[0x01]       & FT1284_DATA_LSB;
3463         eeprom->flow_control   =  buf[0x01]       & FT1284_FLOW_CONTROL;
3464         eeprom->powersave      =  buf[0x01]       & POWER_SAVE_DISABLE_H;
3465         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
3466         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3467         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3468         eeprom->group1_drive   =  buf[0x0d]       & DRIVE_16MA;
3469         eeprom->group1_schmitt =  buf[0x0d]       & IS_SCHMITT;
3470         eeprom->group1_slew    =  buf[0x0d]       & SLOW_SLEW;
3471
3472         for(i=0; i<5; i++)
3473         {
3474             eeprom->cbus_function[2*i  ] =  buf[0x18+i] & 0x0f;
3475             eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3476         }
3477         eeprom->chip = buf[0x1e];
3478         /*FIXME: Decipher more values*/
3479     }
3480     else if (ftdi->type == TYPE_230X)
3481     {
3482         for(i=0; i<4; i++)
3483         {
3484             eeprom->cbus_function[i] =  buf[0x1a + i] & 0xFF;
3485         }
3486         eeprom->group0_drive   =  buf[0x0c]       & 0x03;
3487         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3488         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3489         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x03;
3490         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3491         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
3492
3493         eeprom->invert = buf[0xb];
3494     }
3495
3496     if (verbose)
3497     {
3498         char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
3499         fprintf(stdout, "VID:     0x%04x\n",eeprom->vendor_id);
3500         fprintf(stdout, "PID:     0x%04x\n",eeprom->product_id);
3501         fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
3502
3503         if (eeprom->self_powered)
3504             fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3505         else
3506             fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power,
3507                     (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3508         if (eeprom->manufacturer)
3509             fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3510         if (eeprom->product)
3511             fprintf(stdout, "Product:      %s\n",eeprom->product);
3512         if (eeprom->serial)
3513             fprintf(stdout, "Serial:       %s\n",eeprom->serial);
3514         fprintf(stdout,     "Checksum      : %04x\n", checksum);
3515         if (ftdi->type == TYPE_R) {
3516             fprintf(stdout,     "Internal EEPROM\n");
3517             fprintf(stdout,"Oscillator: %s\n", eeprom->external_oscillator?"External":"Internal");
3518         }
3519         else if (eeprom->chip >= 0x46)
3520             fprintf(stdout,     "Attached EEPROM: 93x%02x\n", eeprom->chip);
3521         if (eeprom->suspend_dbus7)
3522             fprintf(stdout, "Suspend on DBUS7\n");
3523         if (eeprom->suspend_pull_downs)
3524             fprintf(stdout, "Pull IO pins low during suspend\n");
3525         if(eeprom->powersave)
3526         {
3527             if(ftdi->type >= TYPE_232H)
3528                 fprintf(stdout,"Enter low power state on ACBUS7\n");
3529         }
3530         if (eeprom->remote_wakeup)
3531             fprintf(stdout, "Enable Remote Wake Up\n");
3532         fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3533         if (ftdi->type >= TYPE_2232C)
3534             fprintf(stdout,"Channel A has Mode %s%s%s\n",
3535                     channel_mode[eeprom->channel_a_type],
3536                     (eeprom->channel_a_driver)?" VCP":"",
3537                     (eeprom->high_current_a)?" High Current IO":"");
3538         if (ftdi->type == TYPE_232H)
3539         {
3540             fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3541                     (eeprom->clock_polarity)?"HIGH":"LOW",
3542                     (eeprom->data_order)?"LSB":"MSB",
3543                     (eeprom->flow_control)?"":"No ");
3544         }
3545         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3546             fprintf(stdout,"Channel B has Mode %s%s%s\n",
3547                     channel_mode[eeprom->channel_b_type],
3548                     (eeprom->channel_b_driver)?" VCP":"",
3549                     (eeprom->high_current_b)?" High Current IO":"");
3550         if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3551                 eeprom->use_usb_version)
3552             fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3553
3554         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3555         {
3556             fprintf(stdout,"%s has %d mA drive%s%s\n",
3557                     (ftdi->type == TYPE_2232H)?"AL":"A",
3558                     (eeprom->group0_drive+1) *4,
3559                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3560                     (eeprom->group0_slew)?" Slow Slew":"");
3561             fprintf(stdout,"%s has %d mA drive%s%s\n",
3562                     (ftdi->type == TYPE_2232H)?"AH":"B",
3563                     (eeprom->group1_drive+1) *4,
3564                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3565                     (eeprom->group1_slew)?" Slow Slew":"");
3566             fprintf(stdout,"%s has %d mA drive%s%s\n",
3567                     (ftdi->type == TYPE_2232H)?"BL":"C",
3568                     (eeprom->group2_drive+1) *4,
3569                     (eeprom->group2_schmitt)?" Schmitt Input":"",
3570                     (eeprom->group2_slew)?" Slow Slew":"");
3571             fprintf(stdout,"%s has %d mA drive%s%s\n",
3572                     (ftdi->type == TYPE_2232H)?"BH":"D",
3573                     (eeprom->group3_drive+1) *4,
3574                     (eeprom->group3_schmitt)?" Schmitt Input":"",
3575                     (eeprom->group3_slew)?" Slow Slew":"");
3576         }
3577         else if (ftdi->type == TYPE_232H)
3578         {
3579             char *cbush_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
3580                                  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3581                                  "CLK30","CLK15","CLK7_5"
3582                                 };
3583             fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3584                     (eeprom->group0_drive+1) *4,
3585                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3586                     (eeprom->group0_slew)?" Slow Slew":"");
3587             fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3588                     (eeprom->group1_drive+1) *4,
3589                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3590                     (eeprom->group1_slew)?" Slow Slew":"");
3591             for (i=0; i<10; i++)
3592             {
3593                 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3594                     fprintf(stdout,"C%d Function: %s\n", i,
3595                             cbush_mux[eeprom->cbus_function[i]]);
3596             }
3597         }
3598         else if (ftdi->type == TYPE_230X)
3599         {
3600             char *cbusx_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
3601                                  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3602                                  "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#",
3603                                  "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#",
3604                                  "BBRD#", "TIME_STAMP", "AWAKE#",
3605                                 };
3606             fprintf(stdout,"DBUS has %d mA drive%s%s\n",
3607                     (eeprom->group0_drive+1) *4,
3608                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3609                     (eeprom->group0_slew)?" Slow Slew":"");
3610             fprintf(stdout,"CBUS has %d mA drive%s%s\n",
3611                     (eeprom->group1_drive+1) *4,
3612                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3613                     (eeprom->group1_slew)?" Slow Slew":"");
3614             for (i=0; i<4; i++)
3615             {
3616                 if (eeprom->cbus_function[i]<= CBUSX_AWAKE)
3617                     fprintf(stdout,"CBUS%d Function: %s\n", i, cbusx_mux[eeprom->cbus_function[i]]);
3618             }
3619
3620             if (eeprom->invert)
3621                 print_inverted_bits(eeprom->invert);
3622         }
3623
3624         if (ftdi->type == TYPE_R)
3625         {
3626             char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3627                                 "SLEEP","CLK48","CLK24","CLK12","CLK6",
3628                                 "IOMODE","BB_WR","BB_RD"
3629                                };
3630             char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3631
3632             if (eeprom->invert)
3633                 print_inverted_bits(eeprom->invert);
3634
3635             for (i=0; i<5; i++)
3636             {
3637                 if (eeprom->cbus_function[i]<=CBUS_BB_RD)
3638                     fprintf(stdout,"C%d Function: %s\n", i,
3639                             cbus_mux[eeprom->cbus_function[i]]);
3640                 else
3641                 {
3642                     if (i < 4)
3643                         /* Running MPROG show that C0..3 have fixed function Synchronous
3644                            Bit Bang mode */
3645                         fprintf(stdout,"C%d BB Function: %s\n", i,
3646                                 cbus_BB[i]);
3647                     else
3648                         fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3649                 }
3650             }
3651         }
3652     }
3653     return 0;
3654 }
3655
3656 /**
3657    Get a value from the decoded EEPROM structure
3658
3659    \param ftdi pointer to ftdi_context
3660    \param value_name Enum of the value to query
3661    \param value Pointer to store read value
3662
3663    \retval 0: all fine
3664    \retval -1: Value doesn't exist
3665 */
3666 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3667 {
3668     switch (value_name)
3669     {
3670         case VENDOR_ID:
3671             *value = ftdi->eeprom->vendor_id;
3672             break;
3673         case PRODUCT_ID:
3674             *value = ftdi->eeprom->product_id;
3675             break;
3676         case RELEASE_NUMBER:
3677             *value = ftdi->eeprom->release_number;
3678             break;
3679         case SELF_POWERED:
3680             *value = ftdi->eeprom->self_powered;
3681             break;
3682         case REMOTE_WAKEUP:
3683             *value = ftdi->eeprom->remote_wakeup;
3684             break;
3685         case IS_NOT_PNP:
3686             *value = ftdi->eeprom->is_not_pnp;
3687             break;
3688         case SUSPEND_DBUS7:
3689             *value = ftdi->eeprom->suspend_dbus7;
3690             break;
3691         case IN_IS_ISOCHRONOUS:
3692             *value = ftdi->eeprom->in_is_isochronous;
3693             break;
3694         case OUT_IS_ISOCHRONOUS:
3695             *value = ftdi->eeprom->out_is_isochronous;
3696             break;
3697         case SUSPEND_PULL_DOWNS:
3698             *value = ftdi->eeprom->suspend_pull_downs;
3699             break;
3700         case USE_SERIAL:
3701             *value = ftdi->eeprom->use_serial;
3702             break;
3703         case USB_VERSION:
3704             *value = ftdi->eeprom->usb_version;
3705             break;
3706         case USE_USB_VERSION:
3707             *value = ftdi->eeprom->use_usb_version;
3708             break;
3709         case MAX_POWER:
3710             *value = ftdi->eeprom->max_power;
3711             break;
3712         case CHANNEL_A_TYPE:
3713             *value = ftdi->eeprom->channel_a_type;
3714             break;
3715         case CHANNEL_B_TYPE:
3716             *value = ftdi->eeprom->channel_b_type;
3717             break;
3718         case CHANNEL_A_DRIVER:
3719             *value = ftdi->eeprom->channel_a_driver;
3720             break;
3721         case CHANNEL_B_DRIVER:
3722             *value = ftdi->eeprom->channel_b_driver;
3723             break;
3724         case CHANNEL_C_DRIVER:
3725             *value = ftdi->eeprom->channel_c_driver;
3726             break;
3727         case CHANNEL_D_DRIVER:
3728             *value = ftdi->eeprom->channel_d_driver;
3729             break;
3730         case CHANNEL_A_RS485:
3731             *value = ftdi->eeprom->channel_a_rs485enable;
3732             break;
3733         case CHANNEL_B_RS485:
3734             *value = ftdi->eeprom->channel_b_rs485enable;
3735             break;
3736         case CHANNEL_C_RS485:
3737             *value = ftdi->eeprom->channel_c_rs485enable;
3738             break;
3739         case CHANNEL_D_RS485:
3740             *value = ftdi->eeprom->channel_d_rs485enable;
3741             break;
3742         case CBUS_FUNCTION_0:
3743             *value = ftdi->eeprom->cbus_function[0];
3744             break;
3745         case CBUS_FUNCTION_1:
3746             *value = ftdi->eeprom->cbus_function[1];
3747             break;
3748         case CBUS_FUNCTION_2:
3749             *value = ftdi->eeprom->cbus_function[2];
3750             break;
3751         case CBUS_FUNCTION_3:
3752             *value = ftdi->eeprom->cbus_function[3];
3753             break;
3754         case CBUS_FUNCTION_4:
3755             *value = ftdi->eeprom->cbus_function[4];
3756             break;
3757         case CBUS_FUNCTION_5:
3758             *value = ftdi->eeprom->cbus_function[5];
3759             break;
3760         case CBUS_FUNCTION_6:
3761             *value = ftdi->eeprom->cbus_function[6];
3762             break;
3763         case CBUS_FUNCTION_7:
3764             *value = ftdi->eeprom->cbus_function[7];
3765             break;
3766         case CBUS_FUNCTION_8:
3767             *value = ftdi->eeprom->cbus_function[8];
3768             break;
3769         case CBUS_FUNCTION_9:
3770