1 /***************************************************************************
5 copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
6 email : opensource@intra2net.com
7 ***************************************************************************/
9 /***************************************************************************
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; *
15 ***************************************************************************/
18 \mainpage libftdi API documentation
20 Library to talk to FTDI chips. You find the latest versions of libftdi at
21 http://www.intra2net.com/en/developer/libftdi/
23 The library is easy to use. Have a look at this short example:
26 More examples can be found in the "examples" directory.
28 /** \addtogroup libftdi */
39 #define ftdi_error_return(code, str) do { \
40 ftdi->error_str = str; \
44 #define ftdi_error_return_free_device_list(code, str, devs) do { \
45 libusb_free_device_list(devs,1); \
46 ftdi->error_str = str; \
52 Internal function to close usb device pointer.
53 Sets ftdi->usb_dev to NULL.
56 \param ftdi pointer to ftdi_context
60 static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
62 if (ftdi && ftdi->usb_dev)
64 libusb_close (ftdi->usb_dev);
70 Initializes a ftdi_context.
72 \param ftdi pointer to ftdi_context
75 \retval -1: couldn't allocate read buffer
76 \retval -2: couldn't allocate struct buffer
77 \retval -3: libusb_init() failed
79 \remark This should be called before all functions
81 int ftdi_init(struct ftdi_context *ftdi)
83 struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
86 ftdi->usb_read_timeout = 5000;
87 ftdi->usb_write_timeout = 5000;
89 ftdi->type = TYPE_BM; /* chip type */
91 ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
93 ftdi->readbuffer = NULL;
94 ftdi->readbuffer_offset = 0;
95 ftdi->readbuffer_remaining = 0;
96 ftdi->writebuffer_chunksize = 4096;
97 ftdi->max_packet_size = 0;
98 ftdi->error_str = NULL;
99 ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
101 if (libusb_init(&ftdi->usb_ctx) < 0)
102 ftdi_error_return(-3, "libusb_init() failed");
104 ftdi_set_interface(ftdi, INTERFACE_ANY);
105 ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
108 ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
109 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
110 ftdi->eeprom = eeprom;
112 /* All fine. Now allocate the readbuffer */
113 return ftdi_read_data_set_chunksize(ftdi, 4096);
117 Allocate and initialize a new ftdi_context
119 \return a pointer to a new ftdi_context, or NULL on failure
121 struct ftdi_context *ftdi_new(void)
123 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
130 if (ftdi_init(ftdi) != 0)
140 Open selected channels on a chip, otherwise use first channel.
142 \param ftdi pointer to ftdi_context
143 \param interface Interface to use for FT2232C/2232H/4232H chips.
146 \retval -1: unknown interface
147 \retval -2: USB device unavailable
149 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
152 ftdi_error_return(-2, "USB device unavailable");
159 ftdi->index = INTERFACE_A;
165 ftdi->index = INTERFACE_B;
171 ftdi->index = INTERFACE_C;
177 ftdi->index = INTERFACE_D;
182 ftdi_error_return(-1, "Unknown interface");
188 Deinitializes a ftdi_context.
190 \param ftdi pointer to ftdi_context
192 void ftdi_deinit(struct ftdi_context *ftdi)
197 ftdi_usb_close_internal (ftdi);
199 if (ftdi->readbuffer != NULL)
201 free(ftdi->readbuffer);
202 ftdi->readbuffer = NULL;
205 if (ftdi->eeprom != NULL)
207 if (ftdi->eeprom->manufacturer != 0)
209 free(ftdi->eeprom->manufacturer);
210 ftdi->eeprom->manufacturer = 0;
212 if (ftdi->eeprom->product != 0)
214 free(ftdi->eeprom->product);
215 ftdi->eeprom->product = 0;
217 if (ftdi->eeprom->serial != 0)
219 free(ftdi->eeprom->serial);
220 ftdi->eeprom->serial = 0;
228 libusb_exit(ftdi->usb_ctx);
229 ftdi->usb_ctx = NULL;
234 Deinitialize and free an ftdi_context.
236 \param ftdi pointer to ftdi_context
238 void ftdi_free(struct ftdi_context *ftdi)
245 Use an already open libusb device.
247 \param ftdi pointer to ftdi_context
248 \param usb libusb libusb_device_handle to use
250 void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
260 Finds all ftdi devices with given VID:PID on the usb bus. Creates a new
261 ftdi_device_list which needs to be deallocated by ftdi_list_free() after
262 use. With VID:PID 0:0, search for the default devices
263 (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014)
265 \param ftdi pointer to ftdi_context
266 \param devlist Pointer where to store list of found devices
267 \param vendor Vendor ID to search for
268 \param product Product ID to search for
270 \retval >0: number of devices found
271 \retval -3: out of memory
272 \retval -5: libusb_get_device_list() failed
273 \retval -6: libusb_get_device_descriptor() failed
275 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
277 struct ftdi_device_list **curdev;
279 libusb_device **devs;
283 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
284 ftdi_error_return(-5, "libusb_get_device_list() failed");
289 while ((dev = devs[i++]) != NULL)
291 struct libusb_device_descriptor desc;
293 if (libusb_get_device_descriptor(dev, &desc) < 0)
294 ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
296 if (((vendor != 0 && product != 0) &&
297 desc.idVendor == vendor && desc.idProduct == product) ||
298 ((vendor == 0 && product == 0) &&
299 (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
300 || desc.idProduct == 0x6011 || desc.idProduct == 0x6014)))
302 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
304 ftdi_error_return_free_device_list(-3, "out of memory", devs);
306 (*curdev)->next = NULL;
307 (*curdev)->dev = dev;
308 libusb_ref_device(dev);
309 curdev = &(*curdev)->next;
313 libusb_free_device_list(devs,1);
318 Frees a usb device list.
320 \param devlist USB device list created by ftdi_usb_find_all()
322 void ftdi_list_free(struct ftdi_device_list **devlist)
324 struct ftdi_device_list *curdev, *next;
326 for (curdev = *devlist; curdev != NULL;)
329 libusb_unref_device(curdev->dev);
338 Frees a usb device list.
340 \param devlist USB device list created by ftdi_usb_find_all()
342 void ftdi_list_free2(struct ftdi_device_list *devlist)
344 ftdi_list_free(&devlist);
348 Return device ID strings from the usb device.
350 The parameters manufacturer, description and serial may be NULL
351 or pointer to buffers to store the fetched strings.
353 \note Use this function only in combination with ftdi_usb_find_all()
354 as it closes the internal "usb_dev" after use.
356 \param ftdi pointer to ftdi_context
357 \param dev libusb usb_dev to use
358 \param manufacturer Store manufacturer string here if not NULL
359 \param mnf_len Buffer size of manufacturer string
360 \param description Store product description string here if not NULL
361 \param desc_len Buffer size of product description string
362 \param serial Store serial string here if not NULL
363 \param serial_len Buffer size of serial string
366 \retval -1: wrong arguments
367 \retval -4: unable to open device
368 \retval -7: get product manufacturer failed
369 \retval -8: get product description failed
370 \retval -9: get serial number failed
371 \retval -11: libusb_get_device_descriptor() failed
373 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
374 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
376 struct libusb_device_descriptor desc;
378 if ((ftdi==NULL) || (dev==NULL))
381 if (libusb_open(dev, &ftdi->usb_dev) < 0)
382 ftdi_error_return(-4, "libusb_open() failed");
384 if (libusb_get_device_descriptor(dev, &desc) < 0)
385 ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
387 if (manufacturer != NULL)
389 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
391 ftdi_usb_close_internal (ftdi);
392 ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
396 if (description != NULL)
398 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
400 ftdi_usb_close_internal (ftdi);
401 ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
407 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
409 ftdi_usb_close_internal (ftdi);
410 ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
414 ftdi_usb_close_internal (ftdi);
420 * Internal function to determine the maximum packet size.
421 * \param ftdi pointer to ftdi_context
422 * \param dev libusb usb_dev to use
423 * \retval Maximum packet size for this device
425 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
427 struct libusb_device_descriptor desc;
428 struct libusb_config_descriptor *config0;
429 unsigned int packet_size;
432 if (ftdi == NULL || dev == NULL)
435 // Determine maximum packet size. Init with default value.
436 // New hi-speed devices from FTDI use a packet size of 512 bytes
437 // but could be connected to a normal speed USB hub -> 64 bytes packet size.
438 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H )
443 if (libusb_get_device_descriptor(dev, &desc) < 0)
446 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
449 if (desc.bNumConfigurations > 0)
451 if (ftdi->interface < config0->bNumInterfaces)
453 struct libusb_interface interface = config0->interface[ftdi->interface];
454 if (interface.num_altsetting > 0)
456 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
457 if (descriptor.bNumEndpoints > 0)
459 packet_size = descriptor.endpoint[0].wMaxPacketSize;
465 libusb_free_config_descriptor (config0);
470 Opens a ftdi device given by an usb_device.
472 \param ftdi pointer to ftdi_context
473 \param dev libusb usb_dev to use
476 \retval -3: unable to config device
477 \retval -4: unable to open device
478 \retval -5: unable to claim device
479 \retval -6: reset failed
480 \retval -7: set baudrate failed
481 \retval -8: ftdi context invalid
482 \retval -9: libusb_get_device_descriptor() failed
483 \retval -10: libusb_get_config_descriptor() failed
484 \retval -11: libusb_detach_kernel_driver() failed
485 \retval -12: libusb_get_configuration() failed
487 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
489 struct libusb_device_descriptor desc;
490 struct libusb_config_descriptor *config0;
491 int cfg, cfg0, detach_errno = 0;
494 ftdi_error_return(-8, "ftdi context invalid");
496 if (libusb_open(dev, &ftdi->usb_dev) < 0)
497 ftdi_error_return(-4, "libusb_open() failed");
499 if (libusb_get_device_descriptor(dev, &desc) < 0)
500 ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
502 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
503 ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
504 cfg0 = config0->bConfigurationValue;
505 libusb_free_config_descriptor (config0);
507 // Try to detach ftdi_sio kernel module.
509 // The return code is kept in a separate variable and only parsed
510 // if usb_set_configuration() or usb_claim_interface() fails as the
511 // detach operation might be denied and everything still works fine.
512 // Likely scenario is a static ftdi_sio kernel module.
513 if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
515 if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
516 detach_errno = errno;
519 if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
520 ftdi_error_return(-12, "libusb_get_configuration () failed");
521 // set configuration (needed especially for windows)
522 // tolerate EBUSY: one device with one configuration, but two interfaces
523 // and libftdi sessions to both interfaces (e.g. FT2232)
524 if (desc.bNumConfigurations > 0 && cfg != cfg0)
526 if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
528 ftdi_usb_close_internal (ftdi);
529 if (detach_errno == EPERM)
531 ftdi_error_return(-8, "inappropriate permissions on device!");
535 ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
540 if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
542 ftdi_usb_close_internal (ftdi);
543 if (detach_errno == EPERM)
545 ftdi_error_return(-8, "inappropriate permissions on device!");
549 ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
553 if (ftdi_usb_reset (ftdi) != 0)
555 ftdi_usb_close_internal (ftdi);
556 ftdi_error_return(-6, "ftdi_usb_reset failed");
559 // Try to guess chip type
560 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
561 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
562 && desc.iSerialNumber == 0))
563 ftdi->type = TYPE_BM;
564 else if (desc.bcdDevice == 0x200)
565 ftdi->type = TYPE_AM;
566 else if (desc.bcdDevice == 0x500)
567 ftdi->type = TYPE_2232C;
568 else if (desc.bcdDevice == 0x600)
570 else if (desc.bcdDevice == 0x700)
571 ftdi->type = TYPE_2232H;
572 else if (desc.bcdDevice == 0x800)
573 ftdi->type = TYPE_4232H;
574 else if (desc.bcdDevice == 0x900)
575 ftdi->type = TYPE_232H;
577 // Determine maximum packet size
578 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
580 if (ftdi_set_baudrate (ftdi, 9600) != 0)
582 ftdi_usb_close_internal (ftdi);
583 ftdi_error_return(-7, "set baudrate failed");
586 ftdi_error_return(0, "all fine");
590 Opens the first device with a given vendor and product ids.
592 \param ftdi pointer to ftdi_context
593 \param vendor Vendor ID
594 \param product Product ID
596 \retval same as ftdi_usb_open_desc()
598 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
600 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
604 Opens the first device with a given, vendor id, product id,
605 description and serial.
607 \param ftdi pointer to ftdi_context
608 \param vendor Vendor ID
609 \param product Product ID
610 \param description Description to search for. Use NULL if not needed.
611 \param serial Serial to search for. Use NULL if not needed.
614 \retval -3: usb device not found
615 \retval -4: unable to open device
616 \retval -5: unable to claim device
617 \retval -6: reset failed
618 \retval -7: set baudrate failed
619 \retval -8: get product description failed
620 \retval -9: get serial number failed
621 \retval -12: libusb_get_device_list() failed
622 \retval -13: libusb_get_device_descriptor() failed
624 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
625 const char* description, const char* serial)
627 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
631 Opens the index-th device with a given, vendor id, product id,
632 description and serial.
634 \param ftdi pointer to ftdi_context
635 \param vendor Vendor ID
636 \param product Product ID
637 \param description Description to search for. Use NULL if not needed.
638 \param serial Serial to search for. Use NULL if not needed.
639 \param index Number of matching device to open if there are more than one, starts with 0.
642 \retval -1: usb_find_busses() failed
643 \retval -2: usb_find_devices() failed
644 \retval -3: usb device not found
645 \retval -4: unable to open device
646 \retval -5: unable to claim device
647 \retval -6: reset failed
648 \retval -7: set baudrate failed
649 \retval -8: get product description failed
650 \retval -9: get serial number failed
651 \retval -10: unable to close device
652 \retval -11: ftdi context invalid
654 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
655 const char* description, const char* serial, unsigned int index)
658 libusb_device **devs;
663 ftdi_error_return(-11, "ftdi context invalid");
665 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
666 ftdi_error_return(-12, "libusb_get_device_list() failed");
668 while ((dev = devs[i++]) != NULL)
670 struct libusb_device_descriptor desc;
673 if (libusb_get_device_descriptor(dev, &desc) < 0)
674 ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
676 if (desc.idVendor == vendor && desc.idProduct == product)
678 if (libusb_open(dev, &ftdi->usb_dev) < 0)
679 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
681 if (description != NULL)
683 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
685 ftdi_usb_close_internal (ftdi);
686 ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
688 if (strncmp(string, description, sizeof(string)) != 0)
690 ftdi_usb_close_internal (ftdi);
696 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
698 ftdi_usb_close_internal (ftdi);
699 ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
701 if (strncmp(string, serial, sizeof(string)) != 0)
703 ftdi_usb_close_internal (ftdi);
708 ftdi_usb_close_internal (ftdi);
716 res = ftdi_usb_open_dev(ftdi, dev);
717 libusb_free_device_list(devs,1);
723 ftdi_error_return_free_device_list(-3, "device not found", devs);
727 Opens the ftdi-device described by a description-string.
728 Intended to be used for parsing a device-description given as commandline argument.
730 \param ftdi pointer to ftdi_context
731 \param description NULL-terminated description-string, using this format:
732 \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
733 \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")
734 \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
735 \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
737 \note The description format may be extended in later versions.
740 \retval -2: libusb_get_device_list() failed
741 \retval -3: usb device not found
742 \retval -4: unable to open device
743 \retval -5: unable to claim device
744 \retval -6: reset failed
745 \retval -7: set baudrate failed
746 \retval -8: get product description failed
747 \retval -9: get serial number failed
748 \retval -10: unable to close device
749 \retval -11: illegal description format
750 \retval -12: ftdi context invalid
752 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
755 ftdi_error_return(-12, "ftdi context invalid");
757 if (description[0] == 0 || description[1] != ':')
758 ftdi_error_return(-11, "illegal description format");
760 if (description[0] == 'd')
763 libusb_device **devs;
764 unsigned int bus_number, device_address;
767 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
768 ftdi_error_return(-2, "libusb_get_device_list() failed");
770 /* XXX: This doesn't handle symlinks/odd paths/etc... */
771 if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
772 ftdi_error_return_free_device_list(-11, "illegal description format", devs);
774 while ((dev = devs[i++]) != NULL)
777 if (bus_number == libusb_get_bus_number (dev)
778 && device_address == libusb_get_device_address (dev))
780 ret = ftdi_usb_open_dev(ftdi, dev);
781 libusb_free_device_list(devs,1);
787 ftdi_error_return_free_device_list(-3, "device not found", devs);
789 else if (description[0] == 'i' || description[0] == 's')
792 unsigned int product;
793 unsigned int index=0;
794 const char *serial=NULL;
795 const char *startp, *endp;
798 startp=description+2;
799 vendor=strtoul((char*)startp,(char**)&endp,0);
800 if (*endp != ':' || endp == startp || errno != 0)
801 ftdi_error_return(-11, "illegal description format");
804 product=strtoul((char*)startp,(char**)&endp,0);
805 if (endp == startp || errno != 0)
806 ftdi_error_return(-11, "illegal description format");
808 if (description[0] == 'i' && *endp != 0)
810 /* optional index field in i-mode */
812 ftdi_error_return(-11, "illegal description format");
815 index=strtoul((char*)startp,(char**)&endp,0);
816 if (*endp != 0 || endp == startp || errno != 0)
817 ftdi_error_return(-11, "illegal description format");
819 if (description[0] == 's')
822 ftdi_error_return(-11, "illegal description format");
824 /* rest of the description is the serial */
828 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
832 ftdi_error_return(-11, "illegal description format");
837 Resets the ftdi device.
839 \param ftdi pointer to ftdi_context
842 \retval -1: FTDI reset failed
843 \retval -2: USB device unavailable
845 int ftdi_usb_reset(struct ftdi_context *ftdi)
847 if (ftdi == NULL || ftdi->usb_dev == NULL)
848 ftdi_error_return(-2, "USB device unavailable");
850 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
851 SIO_RESET_REQUEST, SIO_RESET_SIO,
852 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
853 ftdi_error_return(-1,"FTDI reset failed");
855 // Invalidate data in the readbuffer
856 ftdi->readbuffer_offset = 0;
857 ftdi->readbuffer_remaining = 0;
863 Clears the read buffer on the chip and the internal read buffer.
865 \param ftdi pointer to ftdi_context
868 \retval -1: read buffer purge failed
869 \retval -2: USB device unavailable
871 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
873 if (ftdi == NULL || ftdi->usb_dev == NULL)
874 ftdi_error_return(-2, "USB device unavailable");
876 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
877 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
878 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
879 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
881 // Invalidate data in the readbuffer
882 ftdi->readbuffer_offset = 0;
883 ftdi->readbuffer_remaining = 0;
889 Clears the write buffer on the chip.
891 \param ftdi pointer to ftdi_context
894 \retval -1: write buffer purge failed
895 \retval -2: USB device unavailable
897 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
899 if (ftdi == NULL || ftdi->usb_dev == NULL)
900 ftdi_error_return(-2, "USB device unavailable");
902 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
903 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
904 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
905 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
911 Clears the buffers on the chip and the internal read buffer.
913 \param ftdi pointer to ftdi_context
916 \retval -1: read buffer purge failed
917 \retval -2: write buffer purge failed
918 \retval -3: USB device unavailable
920 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
924 if (ftdi == NULL || ftdi->usb_dev == NULL)
925 ftdi_error_return(-3, "USB device unavailable");
927 result = ftdi_usb_purge_rx_buffer(ftdi);
931 result = ftdi_usb_purge_tx_buffer(ftdi);
941 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
943 \param ftdi pointer to ftdi_context
946 \retval -1: usb_release failed
947 \retval -3: ftdi context invalid
949 int ftdi_usb_close(struct ftdi_context *ftdi)
954 ftdi_error_return(-3, "ftdi context invalid");
956 if (ftdi->usb_dev != NULL)
957 if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
960 ftdi_usb_close_internal (ftdi);
966 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
967 Function is only used internally
970 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
971 unsigned short *value, unsigned short *index)
973 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
974 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
975 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
976 int divisor, best_divisor, best_baud, best_baud_diff;
977 unsigned long encoded_divisor;
986 divisor = 24000000 / baudrate;
988 if (ftdi->type == TYPE_AM)
990 // Round down to supported fraction (AM only)
991 divisor -= am_adjust_dn[divisor & 7];
994 // Try this divisor and the one above it (because division rounds down)
998 for (i = 0; i < 2; i++)
1000 int try_divisor = divisor + i;
1004 // Round up to supported divisor value
1005 if (try_divisor <= 8)
1007 // Round up to minimum supported divisor
1010 else if (ftdi->type != TYPE_AM && try_divisor < 12)
1012 // BM doesn't support divisors 9 through 11 inclusive
1015 else if (divisor < 16)
1017 // AM doesn't support divisors 9 through 15 inclusive
1022 if (ftdi->type == TYPE_AM)
1024 // Round up to supported fraction (AM only)
1025 try_divisor += am_adjust_up[try_divisor & 7];
1026 if (try_divisor > 0x1FFF8)
1028 // Round down to maximum supported divisor value (for AM)
1029 try_divisor = 0x1FFF8;
1034 if (try_divisor > 0x1FFFF)
1036 // Round down to maximum supported divisor value (for BM)
1037 try_divisor = 0x1FFFF;
1041 // Get estimated baud rate (to nearest integer)
1042 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1043 // Get absolute difference from requested baud rate
1044 if (baud_estimate < baudrate)
1046 baud_diff = baudrate - baud_estimate;
1050 baud_diff = baud_estimate - baudrate;
1052 if (i == 0 || baud_diff < best_baud_diff)
1054 // Closest to requested baud rate so far
1055 best_divisor = try_divisor;
1056 best_baud = baud_estimate;
1057 best_baud_diff = baud_diff;
1060 // Spot on! No point trying
1065 // Encode the best divisor value
1066 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1067 // Deal with special cases for encoded value
1068 if (encoded_divisor == 1)
1070 encoded_divisor = 0; // 3000000 baud
1072 else if (encoded_divisor == 0x4001)
1074 encoded_divisor = 1; // 2000000 baud (BM only)
1076 // Split into "value" and "index" values
1077 *value = (unsigned short)(encoded_divisor & 0xFFFF);
1078 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H )
1080 *index = (unsigned short)(encoded_divisor >> 8);
1082 *index |= ftdi->index;
1085 *index = (unsigned short)(encoded_divisor >> 16);
1087 // Return the nearest baud rate
1092 Sets the chip baud rate
1094 \param ftdi pointer to ftdi_context
1095 \param baudrate baud rate to set
1098 \retval -1: invalid baudrate
1099 \retval -2: setting baudrate failed
1100 \retval -3: USB device unavailable
1102 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1104 unsigned short value, index;
1105 int actual_baudrate;
1107 if (ftdi == NULL || ftdi->usb_dev == NULL)
1108 ftdi_error_return(-3, "USB device unavailable");
1110 if (ftdi->bitbang_enabled)
1112 baudrate = baudrate*4;
1115 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1116 if (actual_baudrate <= 0)
1117 ftdi_error_return (-1, "Silly baudrate <= 0.");
1119 // Check within tolerance (about 5%)
1120 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1121 || ((actual_baudrate < baudrate)
1122 ? (actual_baudrate * 21 < baudrate * 20)
1123 : (baudrate * 21 < actual_baudrate * 20)))
1124 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1126 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1127 SIO_SET_BAUDRATE_REQUEST, value,
1128 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1129 ftdi_error_return (-2, "Setting new baudrate failed");
1131 ftdi->baudrate = baudrate;
1136 Set (RS232) line characteristics.
1137 The break type can only be set via ftdi_set_line_property2()
1138 and defaults to "off".
1140 \param ftdi pointer to ftdi_context
1141 \param bits Number of bits
1142 \param sbit Number of stop bits
1143 \param parity Parity mode
1146 \retval -1: Setting line property failed
1148 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1149 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1151 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1155 Set (RS232) line characteristics
1157 \param ftdi pointer to ftdi_context
1158 \param bits Number of bits
1159 \param sbit Number of stop bits
1160 \param parity Parity mode
1161 \param break_type Break type
1164 \retval -1: Setting line property failed
1165 \retval -2: USB device unavailable
1167 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1168 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1169 enum ftdi_break_type break_type)
1171 unsigned short value = bits;
1173 if (ftdi == NULL || ftdi->usb_dev == NULL)
1174 ftdi_error_return(-2, "USB device unavailable");
1179 value |= (0x00 << 8);
1182 value |= (0x01 << 8);
1185 value |= (0x02 << 8);
1188 value |= (0x03 << 8);
1191 value |= (0x04 << 8);
1198 value |= (0x00 << 11);
1201 value |= (0x01 << 11);
1204 value |= (0x02 << 11);
1211 value |= (0x00 << 14);
1214 value |= (0x01 << 14);
1218 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1219 SIO_SET_DATA_REQUEST, value,
1220 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1221 ftdi_error_return (-1, "Setting new line property failed");
1227 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1229 \param ftdi pointer to ftdi_context
1230 \param buf Buffer with the data
1231 \param size Size of the buffer
1233 \retval -666: USB device unavailable
1234 \retval <0: error code from usb_bulk_write()
1235 \retval >0: number of bytes written
1237 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1242 if (ftdi == NULL || ftdi->usb_dev == NULL)
1243 ftdi_error_return(-666, "USB device unavailable");
1245 while (offset < size)
1247 int write_size = ftdi->writebuffer_chunksize;
1249 if (offset+write_size > size)
1250 write_size = size-offset;
1252 if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1253 ftdi_error_return(-1, "usb bulk write failed");
1255 offset += actual_length;
1261 static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1263 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1264 struct ftdi_context *ftdi = tc->ftdi;
1265 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1267 packet_size = ftdi->max_packet_size;
1269 actual_length = transfer->actual_length;
1271 if (actual_length > 2)
1273 // skip FTDI status bytes.
1274 // Maybe stored in the future to enable modem use
1275 num_of_chunks = actual_length / packet_size;
1276 chunk_remains = actual_length % packet_size;
1277 //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);
1279 ftdi->readbuffer_offset += 2;
1282 if (actual_length > packet_size - 2)
1284 for (i = 1; i < num_of_chunks; i++)
1285 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1286 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1288 if (chunk_remains > 2)
1290 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1291 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1293 actual_length -= 2*num_of_chunks;
1296 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1299 if (actual_length > 0)
1301 // data still fits in buf?
1302 if (tc->offset + actual_length <= tc->size)
1304 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1305 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1306 tc->offset += actual_length;
1308 ftdi->readbuffer_offset = 0;
1309 ftdi->readbuffer_remaining = 0;
1311 /* Did we read exactly the right amount of bytes? */
1312 if (tc->offset == tc->size)
1314 //printf("read_data exact rem %d offset %d\n",
1315 //ftdi->readbuffer_remaining, offset);
1322 // only copy part of the data or size <= readbuffer_chunksize
1323 int part_size = tc->size - tc->offset;
1324 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1325 tc->offset += part_size;
1327 ftdi->readbuffer_offset += part_size;
1328 ftdi->readbuffer_remaining = actual_length - part_size;
1330 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1331 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1337 ret = libusb_submit_transfer (transfer);
1343 static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1345 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1346 struct ftdi_context *ftdi = tc->ftdi;
1348 tc->offset += transfer->actual_length;
1350 if (tc->offset == tc->size)
1356 int write_size = ftdi->writebuffer_chunksize;
1359 if (tc->offset + write_size > tc->size)
1360 write_size = tc->size - tc->offset;
1362 transfer->length = write_size;
1363 transfer->buffer = tc->buf + tc->offset;
1364 ret = libusb_submit_transfer (transfer);
1372 Writes data to the chip. Does not wait for completion of the transfer
1373 nor does it make sure that the transfer was successful.
1375 Use libusb 1.0 asynchronous API.
1377 \param ftdi pointer to ftdi_context
1378 \param buf Buffer with the data
1379 \param size Size of the buffer
1381 \retval NULL: Some error happens when submit transfer
1382 \retval !NULL: Pointer to a ftdi_transfer_control
1385 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1387 struct ftdi_transfer_control *tc;
1388 struct libusb_transfer *transfer;
1389 int write_size, ret;
1391 if (ftdi == NULL || ftdi->usb_dev == NULL)
1394 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1398 transfer = libusb_alloc_transfer(0);
1411 if (size < ftdi->writebuffer_chunksize)
1414 write_size = ftdi->writebuffer_chunksize;
1416 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1417 write_size, ftdi_write_data_cb, tc,
1418 ftdi->usb_write_timeout);
1419 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1421 ret = libusb_submit_transfer(transfer);
1424 libusb_free_transfer(transfer);
1428 tc->transfer = transfer;
1434 Reads data from the chip. Does not wait for completion of the transfer
1435 nor does it make sure that the transfer was successful.
1437 Use libusb 1.0 asynchronous API.
1439 \param ftdi pointer to ftdi_context
1440 \param buf Buffer with the data
1441 \param size Size of the buffer
1443 \retval NULL: Some error happens when submit transfer
1444 \retval !NULL: Pointer to a ftdi_transfer_control
1447 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1449 struct ftdi_transfer_control *tc;
1450 struct libusb_transfer *transfer;
1453 if (ftdi == NULL || ftdi->usb_dev == NULL)
1456 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1464 if (size <= ftdi->readbuffer_remaining)
1466 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1469 ftdi->readbuffer_remaining -= size;
1470 ftdi->readbuffer_offset += size;
1472 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1476 tc->transfer = NULL;
1481 if (ftdi->readbuffer_remaining != 0)
1483 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1485 tc->offset = ftdi->readbuffer_remaining;
1490 transfer = libusb_alloc_transfer(0);
1497 ftdi->readbuffer_remaining = 0;
1498 ftdi->readbuffer_offset = 0;
1500 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);
1501 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1503 ret = libusb_submit_transfer(transfer);
1506 libusb_free_transfer(transfer);
1510 tc->transfer = transfer;
1516 Wait for completion of the transfer.
1518 Use libusb 1.0 asynchronous API.
1520 \param tc pointer to ftdi_transfer_control
1522 \retval < 0: Some error happens
1523 \retval >= 0: Data size transferred
1526 int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1530 while (!tc->completed)
1532 ret = libusb_handle_events(tc->ftdi->usb_ctx);
1535 if (ret == LIBUSB_ERROR_INTERRUPTED)
1537 libusb_cancel_transfer(tc->transfer);
1538 while (!tc->completed)
1539 if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
1541 libusb_free_transfer(tc->transfer);
1549 * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
1550 * at ftdi_read_data_submit(). Therefore, we need to check it here.
1554 if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1556 libusb_free_transfer(tc->transfer);
1563 Configure write buffer chunk size.
1566 \param ftdi pointer to ftdi_context
1567 \param chunksize Chunk size
1570 \retval -1: ftdi context invalid
1572 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1575 ftdi_error_return(-1, "ftdi context invalid");
1577 ftdi->writebuffer_chunksize = chunksize;
1582 Get write buffer chunk size.
1584 \param ftdi pointer to ftdi_context
1585 \param chunksize Pointer to store chunk size in
1588 \retval -1: ftdi context invalid
1590 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1593 ftdi_error_return(-1, "ftdi context invalid");
1595 *chunksize = ftdi->writebuffer_chunksize;
1600 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1602 Automatically strips the two modem status bytes transfered during every read.
1604 \param ftdi pointer to ftdi_context
1605 \param buf Buffer to store data in
1606 \param size Size of the buffer
1608 \retval -666: USB device unavailable
1609 \retval <0: error code from libusb_bulk_transfer()
1610 \retval 0: no data was available
1611 \retval >0: number of bytes read
1614 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1616 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1617 int packet_size = ftdi->max_packet_size;
1618 int actual_length = 1;
1620 if (ftdi == NULL || ftdi->usb_dev == NULL)
1621 ftdi_error_return(-666, "USB device unavailable");
1623 // Packet size sanity check (avoid division by zero)
1624 if (packet_size == 0)
1625 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1627 // everything we want is still in the readbuffer?
1628 if (size <= ftdi->readbuffer_remaining)
1630 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1633 ftdi->readbuffer_remaining -= size;
1634 ftdi->readbuffer_offset += size;
1636 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1640 // something still in the readbuffer, but not enough to satisfy 'size'?
1641 if (ftdi->readbuffer_remaining != 0)
1643 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1646 offset += ftdi->readbuffer_remaining;
1648 // do the actual USB read
1649 while (offset < size && actual_length > 0)
1651 ftdi->readbuffer_remaining = 0;
1652 ftdi->readbuffer_offset = 0;
1653 /* returns how much received */
1654 ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1656 ftdi_error_return(ret, "usb bulk read failed");
1658 if (actual_length > 2)
1660 // skip FTDI status bytes.
1661 // Maybe stored in the future to enable modem use
1662 num_of_chunks = actual_length / packet_size;
1663 chunk_remains = actual_length % packet_size;
1664 //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);
1666 ftdi->readbuffer_offset += 2;
1669 if (actual_length > packet_size - 2)
1671 for (i = 1; i < num_of_chunks; i++)
1672 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1673 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1675 if (chunk_remains > 2)
1677 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1678 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1680 actual_length -= 2*num_of_chunks;
1683 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1686 else if (actual_length <= 2)
1688 // no more data to read?
1691 if (actual_length > 0)
1693 // data still fits in buf?
1694 if (offset+actual_length <= size)
1696 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1697 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1698 offset += actual_length;
1700 /* Did we read exactly the right amount of bytes? */
1702 //printf("read_data exact rem %d offset %d\n",
1703 //ftdi->readbuffer_remaining, offset);
1708 // only copy part of the data or size <= readbuffer_chunksize
1709 int part_size = size-offset;
1710 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1712 ftdi->readbuffer_offset += part_size;
1713 ftdi->readbuffer_remaining = actual_length-part_size;
1714 offset += part_size;
1716 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1717 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1728 Configure read buffer chunk size.
1731 Automatically reallocates the buffer.
1733 \param ftdi pointer to ftdi_context
1734 \param chunksize Chunk size
1737 \retval -1: ftdi context invalid
1739 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1741 unsigned char *new_buf;
1744 ftdi_error_return(-1, "ftdi context invalid");
1746 // Invalidate all remaining data
1747 ftdi->readbuffer_offset = 0;
1748 ftdi->readbuffer_remaining = 0;
1750 /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1751 which is defined in libusb-1.0. Otherwise, each USB read request will
1752 be divided into multiple URBs. This will cause issues on Linux kernel
1753 older than 2.6.32. */
1754 if (chunksize > 16384)
1758 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1759 ftdi_error_return(-1, "out of memory for readbuffer");
1761 ftdi->readbuffer = new_buf;
1762 ftdi->readbuffer_chunksize = chunksize;
1768 Get read buffer chunk size.
1770 \param ftdi pointer to ftdi_context
1771 \param chunksize Pointer to store chunk size in
1774 \retval -1: FTDI context invalid
1776 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1779 ftdi_error_return(-1, "FTDI context invalid");
1781 *chunksize = ftdi->readbuffer_chunksize;
1787 Enable bitbang mode.
1789 \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
1791 \param ftdi pointer to ftdi_context
1792 \param bitmask Bitmask to configure lines.
1793 HIGH/ON value configures a line as output.
1796 \retval -1: can't enable bitbang mode
1797 \retval -2: USB device unavailable
1799 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1801 unsigned short usb_val;
1803 if (ftdi == NULL || ftdi->usb_dev == NULL)
1804 ftdi_error_return(-2, "USB device unavailable");
1806 usb_val = bitmask; // low byte: bitmask
1807 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1808 usb_val |= (ftdi->bitbang_mode << 8);
1810 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1811 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1812 NULL, 0, ftdi->usb_write_timeout) < 0)
1813 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1815 ftdi->bitbang_enabled = 1;
1820 Disable bitbang mode.
1822 \param ftdi pointer to ftdi_context
1825 \retval -1: can't disable bitbang mode
1826 \retval -2: USB device unavailable
1828 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1830 if (ftdi == NULL || ftdi->usb_dev == NULL)
1831 ftdi_error_return(-2, "USB device unavailable");
1833 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)
1834 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1836 ftdi->bitbang_enabled = 0;
1841 Enable/disable bitbang modes.
1843 \param ftdi pointer to ftdi_context
1844 \param bitmask Bitmask to configure lines.
1845 HIGH/ON value configures a line as output.
1846 \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1849 \retval -1: can't enable bitbang mode
1850 \retval -2: USB device unavailable
1852 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1854 unsigned short usb_val;
1856 if (ftdi == NULL || ftdi->usb_dev == NULL)
1857 ftdi_error_return(-2, "USB device unavailable");
1859 usb_val = bitmask; // low byte: bitmask
1860 usb_val |= (mode << 8);
1861 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)
1862 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1864 ftdi->bitbang_mode = mode;
1865 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1870 Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1872 \param ftdi pointer to ftdi_context
1873 \param pins Pointer to store pins into
1876 \retval -1: read pins failed
1877 \retval -2: USB device unavailable
1879 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1881 if (ftdi == NULL || ftdi->usb_dev == NULL)
1882 ftdi_error_return(-2, "USB device unavailable");
1884 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)
1885 ftdi_error_return(-1, "read pins failed");
1893 The FTDI chip keeps data in the internal buffer for a specific
1894 amount of time if the buffer is not full yet to decrease
1895 load on the usb bus.
1897 \param ftdi pointer to ftdi_context
1898 \param latency Value between 1 and 255
1901 \retval -1: latency out of range
1902 \retval -2: unable to set latency timer
1903 \retval -3: USB device unavailable
1905 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1907 unsigned short usb_val;
1910 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1912 if (ftdi == NULL || ftdi->usb_dev == NULL)
1913 ftdi_error_return(-3, "USB device unavailable");
1916 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)
1917 ftdi_error_return(-2, "unable to set latency timer");
1925 \param ftdi pointer to ftdi_context
1926 \param latency Pointer to store latency value in
1929 \retval -1: unable to get latency timer
1930 \retval -2: USB device unavailable
1932 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1934 unsigned short usb_val;
1936 if (ftdi == NULL || ftdi->usb_dev == NULL)
1937 ftdi_error_return(-2, "USB device unavailable");
1939 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)
1940 ftdi_error_return(-1, "reading latency timer failed");
1942 *latency = (unsigned char)usb_val;
1947 Poll modem status information
1949 This function allows the retrieve the two status bytes of the device.
1950 The device sends these bytes also as a header for each read access
1951 where they are discarded by ftdi_read_data(). The chip generates
1952 the two stripped status bytes in the absence of data every 40 ms.
1954 Layout of the first byte:
1955 - B0..B3 - must be 0
1956 - B4 Clear to send (CTS)
1959 - B5 Data set ready (DTS)
1962 - B6 Ring indicator (RI)
1965 - B7 Receive line signal detect (RLSD)
1969 Layout of the second byte:
1970 - B0 Data ready (DR)
1971 - B1 Overrun error (OE)
1972 - B2 Parity error (PE)
1973 - B3 Framing error (FE)
1974 - B4 Break interrupt (BI)
1975 - B5 Transmitter holding register (THRE)
1976 - B6 Transmitter empty (TEMT)
1977 - B7 Error in RCVR FIFO
1979 \param ftdi pointer to ftdi_context
1980 \param status Pointer to store status information in. Must be two bytes.
1983 \retval -1: unable to retrieve status information
1984 \retval -2: USB device unavailable
1986 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1990 if (ftdi == NULL || ftdi->usb_dev == NULL)
1991 ftdi_error_return(-2, "USB device unavailable");
1993 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)
1994 ftdi_error_return(-1, "getting modem status failed");
1996 *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2002 Set flowcontrol for ftdi chip
2004 \param ftdi pointer to ftdi_context
2005 \param flowctrl flow control to use. should be
2006 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
2009 \retval -1: set flow control failed
2010 \retval -2: USB device unavailable
2012 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2014 if (ftdi == NULL || ftdi->usb_dev == NULL)
2015 ftdi_error_return(-2, "USB device unavailable");
2017 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2018 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2019 NULL, 0, ftdi->usb_write_timeout) < 0)
2020 ftdi_error_return(-1, "set flow control failed");
2028 \param ftdi pointer to ftdi_context
2029 \param state state to set line to (1 or 0)
2032 \retval -1: set dtr failed
2033 \retval -2: USB device unavailable
2035 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2037 unsigned short usb_val;
2039 if (ftdi == NULL || ftdi->usb_dev == NULL)
2040 ftdi_error_return(-2, "USB device unavailable");
2043 usb_val = SIO_SET_DTR_HIGH;
2045 usb_val = SIO_SET_DTR_LOW;
2047 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2048 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2049 NULL, 0, ftdi->usb_write_timeout) < 0)
2050 ftdi_error_return(-1, "set dtr failed");
2058 \param ftdi pointer to ftdi_context
2059 \param state state to set line to (1 or 0)
2062 \retval -1: set rts failed
2063 \retval -2: USB device unavailable
2065 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2067 unsigned short usb_val;
2069 if (ftdi == NULL || ftdi->usb_dev == NULL)
2070 ftdi_error_return(-2, "USB device unavailable");
2073 usb_val = SIO_SET_RTS_HIGH;
2075 usb_val = SIO_SET_RTS_LOW;
2077 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2078 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2079 NULL, 0, ftdi->usb_write_timeout) < 0)
2080 ftdi_error_return(-1, "set of rts failed");
2086 Set dtr and rts line in one pass
2088 \param ftdi pointer to ftdi_context
2089 \param dtr DTR state to set line to (1 or 0)
2090 \param rts RTS state to set line to (1 or 0)
2093 \retval -1: set dtr/rts failed
2094 \retval -2: USB device unavailable
2096 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2098 unsigned short usb_val;
2100 if (ftdi == NULL || ftdi->usb_dev == NULL)
2101 ftdi_error_return(-2, "USB device unavailable");
2104 usb_val = SIO_SET_DTR_HIGH;
2106 usb_val = SIO_SET_DTR_LOW;
2109 usb_val |= SIO_SET_RTS_HIGH;
2111 usb_val |= SIO_SET_RTS_LOW;
2113 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2114 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2115 NULL, 0, ftdi->usb_write_timeout) < 0)
2116 ftdi_error_return(-1, "set of rts/dtr failed");
2122 Set the special event character
2124 \param ftdi pointer to ftdi_context
2125 \param eventch Event character
2126 \param enable 0 to disable the event character, non-zero otherwise
2129 \retval -1: unable to set event character
2130 \retval -2: USB device unavailable
2132 int ftdi_set_event_char(struct ftdi_context *ftdi,
2133 unsigned char eventch, unsigned char enable)
2135 unsigned short usb_val;
2137 if (ftdi == NULL || ftdi->usb_dev == NULL)
2138 ftdi_error_return(-2, "USB device unavailable");
2144 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)
2145 ftdi_error_return(-1, "setting event character failed");
2153 \param ftdi pointer to ftdi_context
2154 \param errorch Error character
2155 \param enable 0 to disable the error character, non-zero otherwise
2158 \retval -1: unable to set error character
2159 \retval -2: USB device unavailable
2161 int ftdi_set_error_char(struct ftdi_context *ftdi,
2162 unsigned char errorch, unsigned char enable)
2164 unsigned short usb_val;
2166 if (ftdi == NULL || ftdi->usb_dev == NULL)
2167 ftdi_error_return(-2, "USB device unavailable");
2173 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)
2174 ftdi_error_return(-1, "setting error character failed");
2180 Init eeprom with default values.
2181 \param ftdi pointer to ftdi_context
2182 \param manufacturer String to use as Manufacturer
2183 \param product String to use as Product description
2184 \param serial String to use as Serial number description
2187 \retval -1: No struct ftdi_context
2188 \retval -2: No struct ftdi_eeprom
2190 int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2191 char * product, char * serial)
2193 struct ftdi_eeprom *eeprom;
2196 ftdi_error_return(-1, "No struct ftdi_context");
2198 if (ftdi->eeprom == NULL)
2199 ftdi_error_return(-2,"No struct ftdi_eeprom");
2201 eeprom = ftdi->eeprom;
2202 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2204 eeprom->vendor_id = 0x0403;
2205 eeprom->use_serial = USE_SERIAL_NUM;
2206 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2207 (ftdi->type == TYPE_R))
2208 eeprom->product_id = 0x6001;
2209 else if (ftdi->type == TYPE_4232H)
2210 eeprom->product_id = 0x6011;
2211 else if (ftdi->type == TYPE_232H)
2212 eeprom->product_id = 0x6014;
2214 eeprom->product_id = 0x6010;
2215 if (ftdi->type == TYPE_AM)
2216 eeprom->usb_version = 0x0101;
2218 eeprom->usb_version = 0x0200;
2219 eeprom->max_power = 100;
2221 if (eeprom->manufacturer)
2222 free (eeprom->manufacturer);
2223 eeprom->manufacturer = NULL;
2226 eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2227 if (eeprom->manufacturer)
2228 strcpy(eeprom->manufacturer, manufacturer);
2231 if (eeprom->product)
2232 free (eeprom->product);
2233 eeprom->product = NULL;
2236 eeprom->product = malloc(strlen(product)+1);
2237 if (eeprom->product)
2238 strcpy(eeprom->product, product);
2242 free (eeprom->serial);
2243 eeprom->serial = NULL;
2246 eeprom->serial = malloc(strlen(serial)+1);
2248 strcpy(eeprom->serial, serial);
2252 if (ftdi->type == TYPE_R)
2254 eeprom->max_power = 90;
2255 eeprom->size = 0x80;
2256 eeprom->cbus_function[0] = CBUS_TXLED;
2257 eeprom->cbus_function[1] = CBUS_RXLED;
2258 eeprom->cbus_function[2] = CBUS_TXDEN;
2259 eeprom->cbus_function[3] = CBUS_PWREN;
2260 eeprom->cbus_function[4] = CBUS_SLEEP;
2264 if(ftdi->type == TYPE_232H)
2267 for (i=0; i<10; i++)
2268 eeprom->cbus_function[i] = CBUSH_TRISTATE;
2274 /*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/
2275 void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2280 int mode_low, mode_high;
2281 if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2282 mode_low = CBUSH_TRISTATE;
2284 mode_low = eeprom->cbus_function[2*i];
2285 if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2286 mode_high = CBUSH_TRISTATE;
2288 mode_high = eeprom->cbus_function[2*i];
2290 output[0x18+i] = mode_high <<4 | mode_low;
2294 Build binary buffer from ftdi_eeprom structure.
2295 Output is suitable for ftdi_write_eeprom().
2297 \param ftdi pointer to ftdi_context
2299 \retval >=0: size of eeprom user area in bytes
2300 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2301 \retval -2: Invalid eeprom or ftdi pointer
2302 \retval -3: Invalid cbus function setting (FIXME: Not in the code?)
2303 \retval -4: Chip doesn't support invert (FIXME: Not in the code?)
2304 \retval -5: Chip doesn't support high current drive (FIXME: Not in the code?)
2305 \retval -6: No connected EEPROM or EEPROM Type unknown
2307 int ftdi_eeprom_build(struct ftdi_context *ftdi)
2309 unsigned char i, j, eeprom_size_mask;
2310 unsigned short checksum, value;
2311 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2313 struct ftdi_eeprom *eeprom;
2314 unsigned char * output;
2317 ftdi_error_return(-2,"No context");
2318 if (ftdi->eeprom == NULL)
2319 ftdi_error_return(-2,"No eeprom structure");
2321 eeprom= ftdi->eeprom;
2322 output = eeprom->buf;
2324 if (eeprom->chip == -1)
2325 ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2327 if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2328 eeprom->size = 0x100;
2330 eeprom->size = 0x80;
2332 if (eeprom->manufacturer != NULL)
2333 manufacturer_size = strlen(eeprom->manufacturer);
2334 if (eeprom->product != NULL)
2335 product_size = strlen(eeprom->product);
2336 if (eeprom->serial != NULL)
2337 serial_size = strlen(eeprom->serial);
2339 // eeprom size check
2344 user_area_size = 96; // base size for strings (total of 48 characters)
2347 user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2350 user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2352 case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2354 user_area_size = 86;
2360 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2362 if (user_area_size < 0)
2363 ftdi_error_return(-1,"eeprom size exceeded");
2366 memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2368 // Bytes and Bits set for all Types
2370 // Addr 02: Vendor ID
2371 output[0x02] = eeprom->vendor_id;
2372 output[0x03] = eeprom->vendor_id >> 8;
2374 // Addr 04: Product ID
2375 output[0x04] = eeprom->product_id;
2376 output[0x05] = eeprom->product_id >> 8;
2378 // Addr 06: Device release number (0400h for BM features)
2379 output[0x06] = 0x00;
2383 output[0x07] = 0x02;
2386 output[0x07] = 0x04;
2389 output[0x07] = 0x05;
2392 output[0x07] = 0x06;
2395 output[0x07] = 0x07;
2398 output[0x07] = 0x08;
2401 output[0x07] = 0x09;
2404 output[0x07] = 0x00;
2407 // Addr 08: Config descriptor
2409 // Bit 6: 1 if this device is self powered, 0 if bus powered
2410 // Bit 5: 1 if this device uses remote wakeup
2411 // Bit 4-0: reserved - 0
2413 if (eeprom->self_powered == 1)
2415 if (eeprom->remote_wakeup == 1)
2419 // Addr 09: Max power consumption: max power = value * 2 mA
2420 output[0x09] = eeprom->max_power>>1;
2422 if (ftdi->type != TYPE_AM)
2424 // Addr 0A: Chip configuration
2425 // Bit 7: 0 - reserved
2426 // Bit 6: 0 - reserved
2427 // Bit 5: 0 - reserved
2428 // Bit 4: 1 - Change USB version
2429 // Bit 3: 1 - Use the serial number string
2430 // Bit 2: 1 - Enable suspend pull downs for lower power
2431 // Bit 1: 1 - Out EndPoint is Isochronous
2432 // Bit 0: 1 - In EndPoint is Isochronous
2435 if (eeprom->in_is_isochronous == 1)
2437 if (eeprom->out_is_isochronous == 1)
2443 // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2444 // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2462 /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2463 eeprom_size_mask = eeprom->size -1;
2465 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2466 // Addr 0F: Length of manufacturer string
2467 // Output manufacturer
2468 output[0x0E] = i; // calculate offset
2469 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2470 output[i & eeprom_size_mask] = 0x03, i++; // type: string
2471 for (j = 0; j < manufacturer_size; j++)
2473 output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2474 output[i & eeprom_size_mask] = 0x00, i++;
2476 output[0x0F] = manufacturer_size*2 + 2;
2478 // Addr 10: Offset of the product string + 0x80, calculated later
2479 // Addr 11: Length of product string
2480 output[0x10] = i | 0x80; // calculate offset
2481 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2482 output[i & eeprom_size_mask] = 0x03, i++;
2483 for (j = 0; j < product_size; j++)
2485 output[i & eeprom_size_mask] = eeprom->product[j], i++;
2486 output[i & eeprom_size_mask] = 0x00, i++;
2488 output[0x11] = product_size*2 + 2;
2490 // Addr 12: Offset of the serial string + 0x80, calculated later
2491 // Addr 13: Length of serial string
2492 output[0x12] = i | 0x80; // calculate offset
2493 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2494 output[i & eeprom_size_mask] = 0x03, i++;
2495 for (j = 0; j < serial_size; j++)
2497 output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2498 output[i & eeprom_size_mask] = 0x00, i++;
2501 // Legacy port name and PnP fields for FT2232 and newer chips
2502 if (ftdi->type > TYPE_BM)
2504 output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2506 output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2508 output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2512 output[0x13] = serial_size*2 + 2;
2514 if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2516 if (eeprom->use_serial == USE_SERIAL_NUM )
2517 output[0x0A] |= USE_SERIAL_NUM;
2519 output[0x0A] &= ~USE_SERIAL_NUM;
2522 /* Bytes and Bits specific to (some) types
2523 Write linear, as this allows easier fixing*/
2529 output[0x0C] = eeprom->usb_version & 0xff;
2530 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2531 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2532 output[0x0A] |= USE_USB_VERSION_BIT;
2534 output[0x0A] &= ~USE_USB_VERSION_BIT;
2539 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0x7):0;
2540 if ( eeprom->channel_a_driver == DRIVER_VCP)
2541 output[0x00] |= DRIVER_VCP;
2543 output[0x00] &= ~DRIVER_VCP;
2545 if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2546 output[0x00] |= HIGH_CURRENT_DRIVE;
2548 output[0x00] &= ~HIGH_CURRENT_DRIVE;
2550 output[0x01] = (eeprom->channel_b_type)?((1<<(eeprom->channel_b_type)) & 0x7):0;
2551 if ( eeprom->channel_b_driver == DRIVER_VCP)
2552 output[0x01] |= DRIVER_VCP;
2554 output[0x01] &= ~DRIVER_VCP;
2556 if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2557 output[0x01] |= HIGH_CURRENT_DRIVE;
2559 output[0x01] &= ~HIGH_CURRENT_DRIVE;
2561 if (eeprom->in_is_isochronous == 1)
2562 output[0x0A] |= 0x1;
2564 output[0x0A] &= ~0x1;
2565 if (eeprom->out_is_isochronous == 1)
2566 output[0x0A] |= 0x2;
2568 output[0x0A] &= ~0x2;
2569 if (eeprom->suspend_pull_downs == 1)
2570 output[0x0A] |= 0x4;
2572 output[0x0A] &= ~0x4;
2573 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2574 output[0x0A] |= USE_USB_VERSION_BIT;
2576 output[0x0A] &= ~USE_USB_VERSION_BIT;
2578 output[0x0C] = eeprom->usb_version & 0xff;
2579 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2580 output[0x14] = eeprom->chip;
2583 if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2584 output[0x00] |= HIGH_CURRENT_DRIVE_R;
2585 output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2587 if (eeprom->suspend_pull_downs == 1)
2588 output[0x0A] |= 0x4;
2590 output[0x0A] &= ~0x4;
2591 output[0x0B] = eeprom->invert;
2592 output[0x0C] = eeprom->usb_version & 0xff;
2593 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2595 if (eeprom->cbus_function[0] > CBUS_BB)
2596 output[0x14] = CBUS_TXLED;
2598 output[0x14] = eeprom->cbus_function[0];
2600 if (eeprom->cbus_function[1] > CBUS_BB)
2601 output[0x14] |= CBUS_RXLED<<4;
2603 output[0x14] |= eeprom->cbus_function[1]<<4;
2605 if (eeprom->cbus_function[2] > CBUS_BB)
2606 output[0x15] = CBUS_TXDEN;
2608 output[0x15] = eeprom->cbus_function[2];
2610 if (eeprom->cbus_function[3] > CBUS_BB)
2611 output[0x15] |= CBUS_PWREN<<4;
2613 output[0x15] |= eeprom->cbus_function[3]<<4;
2615 if (eeprom->cbus_function[4] > CBUS_CLK6)
2616 output[0x16] = CBUS_SLEEP;
2618 output[0x16] = eeprom->cbus_function[4];
2621 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0x7):0;
2622 if ( eeprom->channel_a_driver == DRIVER_VCP)
2623 output[0x00] |= DRIVER_VCP;
2625 output[0x00] &= ~DRIVER_VCP;
2627 output[0x01] = (eeprom->channel_b_type)?((1<<(eeprom->channel_b_type)) & 0x7):0;
2628 if ( eeprom->channel_b_driver == DRIVER_VCP)
2629 output[0x01] |= DRIVER_VCP;
2631 output[0x01] &= ~DRIVER_VCP;
2632 if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2633 output[0x01] |= SUSPEND_DBUS7_BIT;
2635 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2637 if (eeprom->suspend_pull_downs == 1)
2638 output[0x0A] |= 0x4;
2640 output[0x0A] &= ~0x4;
2642 if (eeprom->group0_drive > DRIVE_16MA)
2643 output[0x0c] |= DRIVE_16MA;
2645 output[0x0c] |= eeprom->group0_drive;
2646 if (eeprom->group0_schmitt == IS_SCHMITT)
2647 output[0x0c] |= IS_SCHMITT;
2648 if (eeprom->group0_slew == SLOW_SLEW)
2649 output[0x0c] |= SLOW_SLEW;
2651 if (eeprom->group1_drive > DRIVE_16MA)
2652 output[0x0c] |= DRIVE_16MA<<4;
2654 output[0x0c] |= eeprom->group1_drive<<4;
2655 if (eeprom->group1_schmitt == IS_SCHMITT)
2656 output[0x0c] |= IS_SCHMITT<<4;
2657 if (eeprom->group1_slew == SLOW_SLEW)
2658 output[0x0c] |= SLOW_SLEW<<4;
2660 if (eeprom->group2_drive > DRIVE_16MA)
2661 output[0x0d] |= DRIVE_16MA;
2663 output[0x0d] |= eeprom->group2_drive;
2664 if (eeprom->group2_schmitt == IS_SCHMITT)
2665 output[0x0d] |= IS_SCHMITT;
2666 if (eeprom->group2_slew == SLOW_SLEW)
2667 output[0x0d] |= SLOW_SLEW;
2669 if (eeprom->group3_drive > DRIVE_16MA)
2670 output[0x0d] |= DRIVE_16MA<<4;
2672 output[0x0d] |= eeprom->group3_drive<<4;
2673 if (eeprom->group3_schmitt == IS_SCHMITT)
2674 output[0x0d] |= IS_SCHMITT<<4;
2675 if (eeprom->group3_slew == SLOW_SLEW)
2676 output[0x0d] |= SLOW_SLEW<<4;
2678 output[0x18] = eeprom->chip;
2682 output[0x18] = eeprom->chip;
2683 fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2686 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0xf):0;
2687 if ( eeprom->channel_a_driver == DRIVER_VCP)
2688 output[0x00] |= DRIVER_VCPH;
2690 output[0x00] &= ~DRIVER_VCPH;
2691 if (eeprom->powersave)
2692 output[0x01] |= POWER_SAVE_DISABLE_H;
2694 output[0x01] &= ~POWER_SAVE_DISABLE_H;
2695 if (eeprom->clock_polarity)
2696 output[0x01] |= FT1284_CLK_IDLE_STATE;
2698 output[0x01] &= ~FT1284_CLK_IDLE_STATE;
2699 if (eeprom->data_order)
2700 output[0x01] |= FT1284_DATA_LSB;
2702 output[0x01] &= ~FT1284_DATA_LSB;
2703 if (eeprom->flow_control)
2704 output[0x01] |= FT1284_FLOW_CONTROL;
2706 output[0x01] &= ~FT1284_FLOW_CONTROL;
2707 if (eeprom->group0_drive > DRIVE_16MA)
2708 output[0x0c] |= DRIVE_16MA;
2710 output[0x0c] |= eeprom->group0_drive;
2711 if (eeprom->group0_schmitt == IS_SCHMITT)
2712 output[0x0c] |= IS_SCHMITT;
2713 if (eeprom->group0_slew == SLOW_SLEW)
2714 output[0x0c] |= SLOW_SLEW;
2716 if (eeprom->group1_drive > DRIVE_16MA)
2717 output[0x0d] |= DRIVE_16MA;
2719 output[0x0d] |= eeprom->group1_drive;
2720 if (eeprom->group1_schmitt == IS_SCHMITT)
2721 output[0x0d] |= IS_SCHMITT;
2722 if (eeprom->group1_slew == SLOW_SLEW)
2723 output[0x0d] |= SLOW_SLEW;
2725 set_ft232h_cbus(eeprom, output);
2727 output[0x1e] = eeprom->chip;
2728 fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
2733 // calculate checksum
2736 for (i = 0; i < eeprom->size/2-1; i++)
2738 value = output[i*2];
2739 value += output[(i*2)+1] << 8;
2741 checksum = value^checksum;
2742 checksum = (checksum << 1) | (checksum >> 15);
2745 output[eeprom->size-2] = checksum;
2746 output[eeprom->size-1] = checksum >> 8;
2748 return user_area_size;
2750 /* FTD2XX doesn't allow to set multiple bits in the interface mode bitfield*/
2751 unsigned char bit2type(unsigned char bits)
2761 fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
2768 Decode binary EEPROM image into an ftdi_eeprom structure.
2770 \param ftdi pointer to ftdi_context
2771 \param verbose Decode EEPROM on stdout
2774 \retval -1: something went wrong
2776 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2777 FIXME: Strings are malloc'ed here and should be freed somewhere
2779 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2782 unsigned short checksum, eeprom_checksum, value;
2783 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2785 struct ftdi_eeprom *eeprom;
2786 unsigned char *buf = ftdi->eeprom->buf;
2790 ftdi_error_return(-1,"No context");
2791 if (ftdi->eeprom == NULL)
2792 ftdi_error_return(-1,"No eeprom structure");
2794 eeprom = ftdi->eeprom;
2795 eeprom_size = eeprom->size;
2797 // Addr 02: Vendor ID
2798 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2800 // Addr 04: Product ID
2801 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2803 release = buf[0x06] + (buf[0x07]<<8);
2805 // Addr 08: Config descriptor
2807 // Bit 6: 1 if this device is self powered, 0 if bus powered
2808 // Bit 5: 1 if this device uses remote wakeup
2809 eeprom->self_powered = buf[0x08] & 0x40;
2810 eeprom->remote_wakeup = buf[0x08] & 0x20;
2812 // Addr 09: Max power consumption: max power = value * 2 mA
2813 eeprom->max_power = buf[0x09];
2815 // Addr 0A: Chip configuration
2816 // Bit 7: 0 - reserved
2817 // Bit 6: 0 - reserved
2818 // Bit 5: 0 - reserved
2819 // Bit 4: 1 - Change USB version on BM and 2232C
2820 // Bit 3: 1 - Use the serial number string
2821 // Bit 2: 1 - Enable suspend pull downs for lower power
2822 // Bit 1: 1 - Out EndPoint is Isochronous
2823 // Bit 0: 1 - In EndPoint is Isochronous
2825 eeprom->in_is_isochronous = buf[0x0A]&0x01;
2826 eeprom->out_is_isochronous = buf[0x0A]&0x02;
2827 eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2828 eeprom->use_serial = buf[0x0A] & USE_SERIAL_NUM;
2829 eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT;
2831 // Addr 0C: USB version low byte when 0x0A
2832 // Addr 0D: USB version high byte when 0x0A
2833 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2835 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2836 // Addr 0F: Length of manufacturer string
2837 manufacturer_size = buf[0x0F]/2;
2838 if (eeprom->manufacturer)
2839 free(eeprom->manufacturer);
2840 if (manufacturer_size > 0)
2842 eeprom->manufacturer = malloc(manufacturer_size);
2843 if (eeprom->manufacturer)
2845 // Decode manufacturer
2846 i = buf[0x0E] & (eeprom_size -1); // offset
2847 for (j=0;j<manufacturer_size-1;j++)
2849 eeprom->manufacturer[j] = buf[2*j+i+2];
2851 eeprom->manufacturer[j] = '\0';
2854 else eeprom->manufacturer = NULL;
2856 // Addr 10: Offset of the product string + 0x80, calculated later
2857 // Addr 11: Length of product string
2858 if (eeprom->product)
2859 free(eeprom->product);
2860 product_size = buf[0x11]/2;
2861 if (product_size > 0)
2863 eeprom->product = malloc(product_size);
2864 if (eeprom->product)
2866 // Decode product name
2867 i = buf[0x10] & (eeprom_size -1); // offset
2868 for (j=0;j<product_size-1;j++)
2870 eeprom->product[j] = buf[2*j+i+2];
2872 eeprom->product[j] = '\0';
2875 else eeprom->product = NULL;
2877 // Addr 12: Offset of the serial string + 0x80, calculated later
2878 // Addr 13: Length of serial string
2880 free(eeprom->serial);
2881 serial_size = buf[0x13]/2;
2882 if (serial_size > 0)
2884 eeprom->serial = malloc(serial_size);
2888 i = buf[0x12] & (eeprom_size -1); // offset
2889 for (j=0;j<serial_size-1;j++)
2891 eeprom->serial[j] = buf[2*j+i+2];
2893 eeprom->serial[j] = '\0';
2896 else eeprom->serial = NULL;
2901 for (i = 0; i < eeprom_size/2-1; i++)
2904 value += buf[(i*2)+1] << 8;
2906 checksum = value^checksum;
2907 checksum = (checksum << 1) | (checksum >> 15);
2910 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2912 if (eeprom_checksum != checksum)
2914 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2915 ftdi_error_return(-1,"EEPROM checksum error");
2918 eeprom->channel_a_type = 0;
2919 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2923 else if (ftdi->type == TYPE_2232C)
2925 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2926 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2927 eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
2928 eeprom->channel_b_type = buf[0x01] & 0x7;
2929 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2930 eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
2931 eeprom->chip = buf[0x14];
2933 else if (ftdi->type == TYPE_R)
2935 /* TYPE_R flags D2XX, not VCP as all others*/
2936 eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2937 eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2938 if ( (buf[0x01]&0x40) != 0x40)
2940 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2941 " If this happened with the\n"
2942 " EEPROM programmed by FTDI tools, please report "
2943 "to libftdi@developer.intra2net.com\n");
2945 eeprom->chip = buf[0x16];
2946 // Addr 0B: Invert data lines
2947 // Works only on FT232R, not FT245R, but no way to distinguish
2948 eeprom->invert = buf[0x0B];
2949 // Addr 14: CBUS function: CBUS0, CBUS1
2950 // Addr 15: CBUS function: CBUS2, CBUS3
2951 // Addr 16: CBUS function: CBUS5
2952 eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2953 eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2954 eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2955 eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2956 eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2958 else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
2960 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2961 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2962 eeprom->channel_b_type = buf[0x01] & 0x7;
2963 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2965 if (ftdi->type == TYPE_2232H)
2966 eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
2968 eeprom->chip = buf[0x18];
2969 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
2970 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
2971 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
2972 eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
2973 eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
2974 eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
2975 eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
2976 eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
2977 eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
2978 eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
2979 eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
2980 eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
2982 else if (ftdi->type == TYPE_232H)
2986 eeprom->channel_a_type = buf[0x00] & 0xf;
2987 eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
2988 eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
2989 eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
2990 eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
2991 eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
2992 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
2993 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
2994 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
2995 eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
2996 eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
2997 eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
3001 eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
3002 eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3004 eeprom->chip = buf[0x1e];
3005 /*FIXME: Decipher more values*/
3010 char *channel_mode[] = {"UART","245","CPU", "OPTO", "FT1284"};
3011 fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
3012 fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
3013 fprintf(stdout, "Release: 0x%04x\n",release);
3015 if (eeprom->self_powered)
3016 fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3018 fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
3019 (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3020 if (eeprom->manufacturer)
3021 fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3022 if (eeprom->product)
3023 fprintf(stdout, "Product: %s\n",eeprom->product);
3025 fprintf(stdout, "Serial: %s\n",eeprom->serial);
3026 fprintf(stdout, "Checksum : %04x\n", checksum);
3027 if (ftdi->type == TYPE_R)
3028 fprintf(stdout, "Internal EEPROM\n");
3029 else if (eeprom->chip >= 0x46)
3030 fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
3031 if (eeprom->suspend_dbus7)
3032 fprintf(stdout, "Suspend on DBUS7\n");
3033 if (eeprom->suspend_pull_downs)
3034 fprintf(stdout, "Pull IO pins low during suspend\n");
3035 if(eeprom->powersave)
3037 if(ftdi->type >= TYPE_232H)
3038 fprintf(stdout,"Enter low power state on ACBUS7\n");
3040 if (eeprom->remote_wakeup)
3041 fprintf(stdout, "Enable Remote Wake Up\n");
3042 fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3043 if (ftdi->type >= TYPE_2232C)
3044 fprintf(stdout,"Channel A has Mode %s%s%s\n",
3045 channel_mode[eeprom->channel_a_type],
3046 (eeprom->channel_a_driver)?" VCP":"",
3047 (eeprom->high_current_a)?" High Current IO":"");
3048 if (ftdi->type >= TYPE_232H)
3050 fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3051 (eeprom->clock_polarity)?"HIGH":"LOW",
3052 (eeprom->data_order)?"LSB":"MSB",
3053 (eeprom->flow_control)?"":"No ");
3055 if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
3056 fprintf(stdout,"Channel B has Mode %s%s%s\n",
3057 channel_mode[eeprom->channel_b_type],
3058 (eeprom->channel_b_driver)?" VCP":"",
3059 (eeprom->high_current_b)?" High Current IO":"");
3060 if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3061 eeprom->use_usb_version == USE_USB_VERSION_BIT)
3062 fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3064 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3066 fprintf(stdout,"%s has %d mA drive%s%s\n",
3067 (ftdi->type == TYPE_2232H)?"AL":"A",
3068 (eeprom->group0_drive+1) *4,
3069 (eeprom->group0_schmitt)?" Schmitt Input":"",
3070 (eeprom->group0_slew)?" Slow Slew":"");
3071 fprintf(stdout,"%s has %d mA drive%s%s\n",
3072 (ftdi->type == TYPE_2232H)?"AH":"B",
3073 (eeprom->group1_drive+1) *4,
3074 (eeprom->group1_schmitt)?" Schmitt Input":"",
3075 (eeprom->group1_slew)?" Slow Slew":"");
3076 fprintf(stdout,"%s has %d mA drive%s%s\n",
3077 (ftdi->type == TYPE_2232H)?"BL":"C",
3078 (eeprom->group2_drive+1) *4,
3079 (eeprom->group2_schmitt)?" Schmitt Input":"",
3080 (eeprom->group2_slew)?" Slow Slew":"");
3081 fprintf(stdout,"%s has %d mA drive%s%s\n",
3082 (ftdi->type == TYPE_2232H)?"BH":"D",
3083 (eeprom->group3_drive+1) *4,
3084 (eeprom->group3_schmitt)?" Schmitt Input":"",
3085 (eeprom->group3_slew)?" Slow Slew":"");
3087 else if (ftdi->type == TYPE_232H)
3090 char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3091 "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3092 "CLK30","CLK15","CLK7_5"
3094 fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3095 (eeprom->group0_drive+1) *4,
3096 (eeprom->group0_schmitt)?" Schmitt Input":"",
3097 (eeprom->group0_slew)?" Slow Slew":"");
3098 fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3099 (eeprom->group1_drive+1) *4,
3100 (eeprom->group1_schmitt)?" Schmitt Input":"",
3101 (eeprom->group1_slew)?" Slow Slew":"");
3102 for (i=0; i<10; i++)
3104 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3105 fprintf(stdout,"C%d Function: %s\n", i,
3106 cbush_mux[eeprom->cbus_function[i]]);
3111 if (ftdi->type == TYPE_R)
3113 char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3114 "SLEEP","CLK48","CLK24","CLK12","CLK6",
3115 "IOMODE","BB_WR","BB_RD"
3117 char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3121 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
3122 fprintf(stdout,"Inverted bits:");
3124 if ((eeprom->invert & (1<<i)) == (1<<i))
3125 fprintf(stdout," %s",r_bits[i]);
3126 fprintf(stdout,"\n");
3130 if (eeprom->cbus_function[i]<CBUS_BB)
3131 fprintf(stdout,"C%d Function: %s\n", i,
3132 cbus_mux[eeprom->cbus_function[i]]);
3136 /* Running MPROG show that C0..3 have fixed function Synchronous
3138 fprintf(stdout,"C%d BB Function: %s\n", i,
3141 fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3150 Get a value from the decoded EEPROM structure
3152 \param ftdi pointer to ftdi_context
3153 \param value_name Enum of the value to query
3154 \param value Pointer to store read value
3157 \retval -1: Value doesn't exist
3159 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3164 *value = ftdi->eeprom->vendor_id;
3167 *value = ftdi->eeprom->product_id;
3170 *value = ftdi->eeprom->self_powered;
3173 *value = ftdi->eeprom->remote_wakeup;
3176 *value = ftdi->eeprom->is_not_pnp;
3179 *value = ftdi->eeprom->suspend_dbus7;
3181 case IN_IS_ISOCHRONOUS:
3182 *value = ftdi->eeprom->in_is_isochronous;
3184 case OUT_IS_ISOCHRONOUS:
3185 *value = ftdi->eeprom->out_is_isochronous;
3187 case SUSPEND_PULL_DOWNS:
3188 *value = ftdi->eeprom->suspend_pull_downs;
3191 *value = ftdi->eeprom->use_serial;
3194 *value = ftdi->eeprom->usb_version;
3196 case USE_USB_VERSION:
3197 *value = ftdi->eeprom->use_usb_version;
3200 *value = ftdi->eeprom->max_power;
3202 case CHANNEL_A_TYPE:
3203 *value = ftdi->eeprom->channel_a_type;
3205 case CHANNEL_B_TYPE:
3206 *value = ftdi->eeprom->channel_b_type;
3208 case CHANNEL_A_DRIVER:
3209 *value = ftdi->eeprom->channel_a_driver;
3211 case CHANNEL_B_DRIVER:
3212 *value = ftdi->eeprom->channel_b_driver;
3214 case CBUS_FUNCTION_0:
3215 *value = ftdi->eeprom->cbus_function[0];
3217 case CBUS_FUNCTION_1:
3218 *value = ftdi->eeprom->cbus_function[1];
3220 case CBUS_FUNCTION_2:
3221 *value = ftdi->eeprom->cbus_function[2];
3223 case CBUS_FUNCTION_3:
3224 *value = ftdi->eeprom->cbus_function[3];
3226 case CBUS_FUNCTION_4:
3227 *value = ftdi->eeprom->cbus_function[4];
3229 case CBUS_FUNCTION_5:
3230 *value = ftdi->eeprom->cbus_function[5];
3232 case CBUS_FUNCTION_6:
3233 *value = ftdi->eeprom->cbus_function[6];
3235 case CBUS_FUNCTION_7:
3236 *value = ftdi->eeprom->cbus_function[7];
3238 case CBUS_FUNCTION_8:
3239 *value = ftdi->eeprom->cbus_function[8];
3241 case CBUS_FUNCTION_9:
3242 *value = ftdi->eeprom->cbus_function[8];
3245 *value = ftdi->eeprom->high_current;
3247 case HIGH_CURRENT_A:
3248 *value = ftdi->eeprom->high_current_a;
3250 case HIGH_CURRENT_B:
3251 *value = ftdi->eeprom->high_current_b;
3254 *value = ftdi->eeprom->invert;
3257 *value = ftdi->eeprom->group0_drive;
3259 case GROUP0_SCHMITT:
3260 *value = ftdi->eeprom->group0_schmitt;
3263 *value = ftdi->eeprom->group0_slew;
3266 *value = ftdi->eeprom->group1_drive;
3268 case GROUP1_SCHMITT:
3269 *value = ftdi->eeprom->group1_schmitt;
3272 *value = ftdi->eeprom->group1_slew;
3275 *value = ftdi->eeprom->group2_drive;
3277 case GROUP2_SCHMITT:
3278 *value = ftdi->eeprom->group2_schmitt;
3281 *value = ftdi->eeprom->group2_slew;
3284 *value = ftdi->eeprom->group3_drive;
3286 case GROUP3_SCHMITT:
3287 *value = ftdi->eeprom->group3_schmitt;
3290 *value = ftdi->eeprom->group3_slew;
3293 *value = ftdi->eeprom->powersave;
3295 case CLOCK_POLARITY:
3296 *value = ftdi->eeprom->clock_polarity;
3299 *value = ftdi->eeprom->data_order;
3302 *value = ftdi->eeprom->flow_control;
3305 *value = ftdi->eeprom->chip;
3308 *value = ftdi->eeprom->size;
3311 ftdi_error_return(-1, "Request for unknown EEPROM value");
3317 Set a value in the decoded EEPROM Structure
3318 No parameter checking is performed
3320 \param ftdi pointer to ftdi_context
3321 \param value_name Enum of the value to set
3325 \retval -1: Value doesn't exist
3326 \retval -2: Value not user settable
3328 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3333 ftdi->eeprom->vendor_id = value;
3336 ftdi->eeprom->product_id = value;
3339 ftdi->eeprom->self_powered = value;
3342 ftdi->eeprom->remote_wakeup = value;
3345 ftdi->eeprom->is_not_pnp = value;
3348 ftdi->eeprom->suspend_dbus7 = value;
3350 case IN_IS_ISOCHRONOUS:
3351 ftdi->eeprom->in_is_isochronous = value;
3353 case OUT_IS_ISOCHRONOUS:
3354 ftdi->eeprom->out_is_isochronous = value;
3356 case SUSPEND_PULL_DOWNS:
3357 ftdi->eeprom->suspend_pull_downs = value;
3360 ftdi->eeprom->use_serial = value;
3363 ftdi->eeprom->usb_version = value;
3365 case USE_USB_VERSION:
3366 ftdi->eeprom->use_usb_version = value;
3369 ftdi->eeprom->max_power = value;
3371 case CHANNEL_A_TYPE:
3372 ftdi->eeprom->channel_a_type = value;
3374 case CHANNEL_B_TYPE:
3375 ftdi->eeprom->channel_b_type = value;
3377 case CHANNEL_A_DRIVER:
3378 ftdi->eeprom->channel_a_driver = value;
3380 case CHANNEL_B_DRIVER:
3381 ftdi->eeprom->channel_b_driver = value;
3383 case CBUS_FUNCTION_0:
3384 ftdi->eeprom->cbus_function[0] = value;
3386 case CBUS_FUNCTION_1:
3387 ftdi->eeprom->cbus_function[1] = value;
3389 case CBUS_FUNCTION_2:
3390 ftdi->eeprom->cbus_function[2] = value;
3392 case CBUS_FUNCTION_3:
3393 ftdi->eeprom->cbus_function[3] = value;
3395 case CBUS_FUNCTION_4:
3396 ftdi->eeprom->cbus_function[4] = value;
3398 case CBUS_FUNCTION_5:
3399 ftdi->eeprom->cbus_function[5] = value;
3401 case CBUS_FUNCTION_6:
3402 ftdi->eeprom->cbus_function[6] = value;
3404 case CBUS_FUNCTION_7:
3405 ftdi->eeprom->cbus_function[7] = value;
3407 case CBUS_FUNCTION_8:
3408 ftdi->eeprom->cbus_function[8] = value;
3410 case CBUS_FUNCTION_9:
3411 ftdi->eeprom->cbus_function[9] = value;
3414 ftdi->eeprom->high_current = value;
3416 case HIGH_CURRENT_A:
3417 ftdi->eeprom->high_current_a = value;
3419 case HIGH_CURRENT_B:
3420 ftdi->eeprom->high_current_b = value;
3423 ftdi->eeprom->invert = value;
3426 ftdi->eeprom->group0_drive = value;
3428 case GROUP0_SCHMITT:
3429 ftdi->eeprom->group0_schmitt = value;
3432 ftdi->eeprom->group0_slew = value;
3435 ftdi->eeprom->group1_drive = value;
3437 case GROUP1_SCHMITT:
3438 ftdi->eeprom->group1_schmitt = value;
3441 ftdi->eeprom->group1_slew = value;
3444 ftdi->eeprom->group2_drive = value;
3446 case GROUP2_SCHMITT:
3447 ftdi->eeprom->group2_schmitt = value;
3450 ftdi->eeprom->group2_slew = value;
3453 ftdi->eeprom->group3_drive = value;
3455 case GROUP3_SCHMITT:
3456 ftdi->eeprom->group3_schmitt = value;
3459 ftdi->eeprom->group3_slew = value;
3462 ftdi->eeprom->chip = value;
3465 ftdi->eeprom->powersave = value;
3467 case CLOCK_POLARITY:
3468 ftdi->eeprom->clock_polarity = value;
3471 ftdi->eeprom->data_order = value;
3474 ftdi->eeprom->flow_control = value;
3477 ftdi_error_return(-2, "EEPROM Value can't be changed");
3479 ftdi_error_return(-1, "Request to unknown EEPROM value");
3484 /** Get the read-only buffer to the binary EEPROM content
3486 \param ftdi pointer to ftdi_context
3487 \param buf buffer to receive EEPROM content
3488 \param size Size of receiving buffer
3491 \retval -1: struct ftdi_contxt or ftdi_eeprom missing
3492 \retval -2: Not enough room to store eeprom
3494 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3496 if (!ftdi || !(ftdi->eeprom))
3497 ftdi_error_return(-1, "No appropriate structure");
3499 if (!buf || size < ftdi->eeprom->size)
3500 ftdi_error_return(-1, "Not enough room to store eeprom");
3502 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3503 if (size > FTDI_MAX_EEPROM_SIZE)
3504 size = FTDI_MAX_EEPROM_SIZE;
3506 memcpy(buf, ftdi->eeprom->buf, size);
3511 /** Set the EEPROM content from the user-supplied prefilled buffer
3513 \param ftdi pointer to ftdi_context
3514 \param buf buffer to read EEPROM content
3515 \param size Size of buffer
3518 \retval -1: struct ftdi_contxt or ftdi_eeprom of buf missing
3520 int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
3522 if (!ftdi || !(ftdi->eeprom) || !buf)
3523 ftdi_error_return(-1, "No appropriate structure");
3525 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3526 if (size > FTDI_MAX_EEPROM_SIZE)
3527 size = FTDI_MAX_EEPROM_SIZE;
3529 memcpy(ftdi->eeprom->buf, buf, size);
3535 Read eeprom location
3537 \param ftdi pointer to ftdi_context
3538 \param eeprom_addr Address of eeprom location to be read
3539 \param eeprom_val Pointer to store read eeprom location
3542 \retval -1: read failed
3543 \retval -2: USB device unavailable
3545 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3547 if (ftdi == NULL || ftdi->usb_dev == NULL)
3548 ftdi_error_return(-2, "USB device unavailable");
3550 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
3551 ftdi_error_return(-1, "reading eeprom failed");
3559 \param ftdi pointer to ftdi_context
3562 \retval -1: read failed
3563 \retval -2: USB device unavailable
3565 int ftdi_read_eeprom(struct ftdi_context *ftdi)
3570 if (ftdi == NULL || ftdi->usb_dev == NULL)
3571 ftdi_error_return(-2, "USB device unavailable");
3572 buf = ftdi->eeprom->buf;
3574 for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3576 if (libusb_control_transfer(
3577 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3578 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3579 ftdi_error_return(-1, "reading eeprom failed");
3582 if (ftdi->type == TYPE_R)
3583 ftdi->eeprom->size = 0x80;
3584 /* Guesses size of eeprom by comparing halves
3585 - will not work with blank eeprom */
3586 else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3587 ftdi->eeprom->size = -1;
3588 else if (memcmp(buf,&buf[0x80],0x80) == 0)
3589 ftdi->eeprom->size = 0x80;
3590 else if (memcmp(buf,&buf[0x40],0x40) == 0)
3591 ftdi->eeprom->size = 0x40;
3593 ftdi->eeprom->size = 0x100;
3598 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3599 Function is only used internally
3602 static unsigned char ftdi_read_chipid_shift(unsigned char value)
3604 return ((value & 1) << 1) |
3605 ((value & 2) << 5) |
3606 ((value & 4) >> 2) |
3607 ((value & 8) << 4) |
3608 ((value & 16) >> 1) |
3609 ((value & 32) >> 1) |
3610 ((value & 64) >> 4) |
3611 ((value & 128) >> 2);
3615 Read the FTDIChip-ID from R-type devices
3617 \param ftdi pointer to ftdi_context
3618 \param chipid Pointer to store FTDIChip-ID
3621 \retval -1: read failed
3622 \retval -2: USB device unavailable
3624 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3626 unsigned int a = 0, b = 0;
3628 if (ftdi == NULL || ftdi->usb_dev == NULL)
3629 ftdi_error_return(-2, "USB device unavailable");
3631 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (unsigned char *)&a, 2, ftdi->usb_read_timeout) == 2)
3633 a = a << 8 | a >> 8;
3634 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (unsigned char *)&b, 2, ftdi->usb_read_timeout) == 2)
3636 b = b << 8 | b >> 8;
3637 a = (a << 16) | (b & 0xFFFF);
3638 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3639 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3640 *chipid = a ^ 0xa5f0f7d1;
3645 ftdi_error_return(-1, "read of FTDIChip-ID failed");
3649 Write eeprom location
3651 \param ftdi pointer to ftdi_context
3652 \param eeprom_addr Address of eeprom location to be written
3653 \param eeprom_val Value to be written
3656 \retval -1: write failed
3657 \retval -2: USB device unavailable
3658 \retval -3: Invalid access to checksum protected area below 0x80
3659 \retval -4: Device can't access unprotected area
3660 \retval -5: Reading chip type failed
3662 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3663 unsigned short eeprom_val)
3665 int chip_type_location;
3666 unsigned short chip_type;
3668 if (ftdi == NULL || ftdi->usb_dev == NULL)
3669 ftdi_error_return(-2, "USB device unavailable");
3671 if (eeprom_addr <0x80)
3672 ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
3679 chip_type_location = 0x14;
3683 chip_type_location = 0x18;
3686 chip_type_location = 0x1e;
3689 ftdi_error_return(-4, "Device can't access unprotected area");
3692 if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3693 ftdi_error_return(-5, "Reading failed failed");
3694 fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3695 if ((chip_type & 0xff) != 0x66)
3697 ftdi_error_return(-6, "EEPROM is not of 93x66");
3700 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3701 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3702 NULL, 0, ftdi->usb_write_timeout) != 0)
3703 ftdi_error_return(-1, "unable to write eeprom");
3711 \param ftdi pointer to ftdi_context
3714 \retval -1: read failed
3715 \retval -2: USB device unavailable
3717 int ftdi_write_eeprom(struct ftdi_context *ftdi)
3719 unsigned short usb_val, status;
3721 unsigned char *eeprom;
3723 if (ftdi == NULL || ftdi->usb_dev == NULL)
3724 ftdi_error_return(-2, "USB device unavailable");
3725 eeprom = ftdi->eeprom->buf;
3727 /* These commands were traced while running MProg */
3728 if ((ret = ftdi_usb_reset(ftdi)) != 0)
3730 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3732 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3735 for (i = 0; i < ftdi->eeprom->size/2; i++)
3737 usb_val = eeprom[i*2];
3738 usb_val += eeprom[(i*2)+1] << 8;
3739 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3740 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3741 NULL, 0, ftdi->usb_write_timeout) < 0)
3742 ftdi_error_return(-1, "unable to write eeprom");
3751 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3753 \param ftdi pointer to ftdi_context
3756 \retval -1: erase failed
3757 \retval -2: USB device unavailable
3758 \retval -3: Writing magic failed
3759 \retval -4: Read EEPROM failed
3760 \retval -5: Unexpected EEPROM value
3762 #define MAGIC 0x55aa
3763 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3765 unsigned short eeprom_value;
3766 if (ftdi == NULL || ftdi->usb_dev == NULL)
3767 ftdi_error_return(-2, "USB device unavailable");
3769 if (ftdi->type == TYPE_R)
3771 ftdi->eeprom->chip = 0;
3775 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3776 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3777 ftdi_error_return(-1, "unable to erase eeprom");
3780 /* detect chip type by writing 0x55AA as magic at word position 0xc0
3781 Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3782 Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3783 Chip is 93x66 if magic is only read at word position 0xc0*/
3784 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3785 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3786 NULL, 0, ftdi->usb_write_timeout) != 0)
3787 ftdi_error_return(-3, "Writing magic failed");
3788 if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3789 ftdi_error_return(-4, "Reading failed failed");
3790 if (eeprom_value == MAGIC)
3792 ftdi->eeprom->chip = 0x46;
3796 if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3797 ftdi_error_return(-4, "Reading failed failed");
3798 if (eeprom_value == MAGIC)
3799 ftdi->eeprom->chip = 0x56;
3802 if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3803 ftdi_error_return(-4, "Reading failed failed");
3804 if (eeprom_value == MAGIC)
3805 ftdi->eeprom->chip = 0x66;
3808 ftdi->eeprom->chip = -1;
3812 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3813 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3814 ftdi_error_return(-1, "unable to erase eeprom");
3819 Get string representation for last error code
3821 \param ftdi pointer to ftdi_context
3823 \retval Pointer to error string
3825 char *ftdi_get_error_string (struct ftdi_context *ftdi)
3830 return ftdi->error_str;
3833 /* @} end of doxygen libftdi group */