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