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