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