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;
2293 /* Return the bits for the encoded EEPROM Structure of a requested Mode
2296 static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip)
2305 case CHANNEL_IS_UART: return 0;
2306 case CHANNEL_IS_FIFO: return 0x01;
2307 case CHANNEL_IS_OPTO: return 0x02;
2308 case CHANNEL_IS_CPU : return 0x04;
2316 case CHANNEL_IS_UART : return 0;
2317 case CHANNEL_IS_FIFO : return 0x01;
2318 case CHANNEL_IS_OPTO : return 0x02;
2319 case CHANNEL_IS_CPU : return 0x04;
2320 case CHANNEL_IS_FT1284 : return 0x08;
2330 Build binary buffer from ftdi_eeprom structure.
2331 Output is suitable for ftdi_write_eeprom().
2333 \param ftdi pointer to ftdi_context
2335 \retval >=0: size of eeprom user area in bytes
2336 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2337 \retval -2: Invalid eeprom or ftdi pointer
2338 \retval -3: Invalid cbus function setting (FIXME: Not in the code?)
2339 \retval -4: Chip doesn't support invert (FIXME: Not in the code?)
2340 \retval -5: Chip doesn't support high current drive (FIXME: Not in the code?)
2341 \retval -6: No connected EEPROM or EEPROM Type unknown
2343 int ftdi_eeprom_build(struct ftdi_context *ftdi)
2345 unsigned char i, j, eeprom_size_mask;
2346 unsigned short checksum, value;
2347 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2349 struct ftdi_eeprom *eeprom;
2350 unsigned char * output;
2353 ftdi_error_return(-2,"No context");
2354 if (ftdi->eeprom == NULL)
2355 ftdi_error_return(-2,"No eeprom structure");
2357 eeprom= ftdi->eeprom;
2358 output = eeprom->buf;
2360 if (eeprom->chip == -1)
2361 ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2363 if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2364 eeprom->size = 0x100;
2366 eeprom->size = 0x80;
2368 if (eeprom->manufacturer != NULL)
2369 manufacturer_size = strlen(eeprom->manufacturer);
2370 if (eeprom->product != NULL)
2371 product_size = strlen(eeprom->product);
2372 if (eeprom->serial != NULL)
2373 serial_size = strlen(eeprom->serial);
2375 // eeprom size check
2380 user_area_size = 96; // base size for strings (total of 48 characters)
2383 user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2386 user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2388 case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2390 user_area_size = 86;
2393 user_area_size = 80;
2399 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2401 if (user_area_size < 0)
2402 ftdi_error_return(-1,"eeprom size exceeded");
2405 memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2407 // Bytes and Bits set for all Types
2409 // Addr 02: Vendor ID
2410 output[0x02] = eeprom->vendor_id;
2411 output[0x03] = eeprom->vendor_id >> 8;
2413 // Addr 04: Product ID
2414 output[0x04] = eeprom->product_id;
2415 output[0x05] = eeprom->product_id >> 8;
2417 // Addr 06: Device release number (0400h for BM features)
2418 output[0x06] = 0x00;
2422 output[0x07] = 0x02;
2425 output[0x07] = 0x04;
2428 output[0x07] = 0x05;
2431 output[0x07] = 0x06;
2434 output[0x07] = 0x07;
2437 output[0x07] = 0x08;
2440 output[0x07] = 0x09;
2443 output[0x07] = 0x00;
2446 // Addr 08: Config descriptor
2448 // Bit 6: 1 if this device is self powered, 0 if bus powered
2449 // Bit 5: 1 if this device uses remote wakeup
2450 // Bit 4-0: reserved - 0
2452 if (eeprom->self_powered == 1)
2454 if (eeprom->remote_wakeup == 1)
2458 // Addr 09: Max power consumption: max power = value * 2 mA
2459 output[0x09] = eeprom->max_power>>1;
2461 if (ftdi->type != TYPE_AM)
2463 // Addr 0A: Chip configuration
2464 // Bit 7: 0 - reserved
2465 // Bit 6: 0 - reserved
2466 // Bit 5: 0 - reserved
2467 // Bit 4: 1 - Change USB version
2468 // Bit 3: 1 - Use the serial number string
2469 // Bit 2: 1 - Enable suspend pull downs for lower power
2470 // Bit 1: 1 - Out EndPoint is Isochronous
2471 // Bit 0: 1 - In EndPoint is Isochronous
2474 if (eeprom->in_is_isochronous == 1)
2476 if (eeprom->out_is_isochronous == 1)
2482 // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2483 // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2501 /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2502 eeprom_size_mask = eeprom->size -1;
2504 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2505 // Addr 0F: Length of manufacturer string
2506 // Output manufacturer
2507 output[0x0E] = i; // calculate offset
2508 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2509 output[i & eeprom_size_mask] = 0x03, i++; // type: string
2510 for (j = 0; j < manufacturer_size; j++)
2512 output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2513 output[i & eeprom_size_mask] = 0x00, i++;
2515 output[0x0F] = manufacturer_size*2 + 2;
2517 // Addr 10: Offset of the product string + 0x80, calculated later
2518 // Addr 11: Length of product string
2519 output[0x10] = i | 0x80; // calculate offset
2520 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2521 output[i & eeprom_size_mask] = 0x03, i++;
2522 for (j = 0; j < product_size; j++)
2524 output[i & eeprom_size_mask] = eeprom->product[j], i++;
2525 output[i & eeprom_size_mask] = 0x00, i++;
2527 output[0x11] = product_size*2 + 2;
2529 // Addr 12: Offset of the serial string + 0x80, calculated later
2530 // Addr 13: Length of serial string
2531 output[0x12] = i | 0x80; // calculate offset
2532 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2533 output[i & eeprom_size_mask] = 0x03, i++;
2534 for (j = 0; j < serial_size; j++)
2536 output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2537 output[i & eeprom_size_mask] = 0x00, i++;
2540 // Legacy port name and PnP fields for FT2232 and newer chips
2541 if (ftdi->type > TYPE_BM)
2543 output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2545 output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2547 output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2551 output[0x13] = serial_size*2 + 2;
2553 if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2555 if (eeprom->use_serial == USE_SERIAL_NUM )
2556 output[0x0A] |= USE_SERIAL_NUM;
2558 output[0x0A] &= ~USE_SERIAL_NUM;
2561 /* Bytes and Bits specific to (some) types
2562 Write linear, as this allows easier fixing*/
2568 output[0x0C] = eeprom->usb_version & 0xff;
2569 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2570 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2571 output[0x0A] |= USE_USB_VERSION_BIT;
2573 output[0x0A] &= ~USE_USB_VERSION_BIT;
2578 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C);
2579 if ( eeprom->channel_a_driver == DRIVER_VCP)
2580 output[0x00] |= DRIVER_VCP;
2582 output[0x00] &= ~DRIVER_VCP;
2584 if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2585 output[0x00] |= HIGH_CURRENT_DRIVE;
2587 output[0x00] &= ~HIGH_CURRENT_DRIVE;
2589 output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C);
2590 if ( eeprom->channel_b_driver == DRIVER_VCP)
2591 output[0x01] |= DRIVER_VCP;
2593 output[0x01] &= ~DRIVER_VCP;
2595 if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2596 output[0x01] |= HIGH_CURRENT_DRIVE;
2598 output[0x01] &= ~HIGH_CURRENT_DRIVE;
2600 if (eeprom->in_is_isochronous == 1)
2601 output[0x0A] |= 0x1;
2603 output[0x0A] &= ~0x1;
2604 if (eeprom->out_is_isochronous == 1)
2605 output[0x0A] |= 0x2;
2607 output[0x0A] &= ~0x2;
2608 if (eeprom->suspend_pull_downs == 1)
2609 output[0x0A] |= 0x4;
2611 output[0x0A] &= ~0x4;
2612 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2613 output[0x0A] |= USE_USB_VERSION_BIT;
2615 output[0x0A] &= ~USE_USB_VERSION_BIT;
2617 output[0x0C] = eeprom->usb_version & 0xff;
2618 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2619 output[0x14] = eeprom->chip;
2622 if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2623 output[0x00] |= HIGH_CURRENT_DRIVE_R;
2624 output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2626 if (eeprom->suspend_pull_downs == 1)
2627 output[0x0A] |= 0x4;
2629 output[0x0A] &= ~0x4;
2630 output[0x0B] = eeprom->invert;
2631 output[0x0C] = eeprom->usb_version & 0xff;
2632 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2634 if (eeprom->cbus_function[0] > CBUS_BB)
2635 output[0x14] = CBUS_TXLED;
2637 output[0x14] = eeprom->cbus_function[0];
2639 if (eeprom->cbus_function[1] > CBUS_BB)
2640 output[0x14] |= CBUS_RXLED<<4;
2642 output[0x14] |= eeprom->cbus_function[1]<<4;
2644 if (eeprom->cbus_function[2] > CBUS_BB)
2645 output[0x15] = CBUS_TXDEN;
2647 output[0x15] = eeprom->cbus_function[2];
2649 if (eeprom->cbus_function[3] > CBUS_BB)
2650 output[0x15] |= CBUS_PWREN<<4;
2652 output[0x15] |= eeprom->cbus_function[3]<<4;
2654 if (eeprom->cbus_function[4] > CBUS_CLK6)
2655 output[0x16] = CBUS_SLEEP;
2657 output[0x16] = eeprom->cbus_function[4];
2660 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H);
2661 if ( eeprom->channel_a_driver == DRIVER_VCP)
2662 output[0x00] |= DRIVER_VCP;
2664 output[0x00] &= ~DRIVER_VCP;
2666 output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H);
2667 if ( eeprom->channel_b_driver == DRIVER_VCP)
2668 output[0x01] |= DRIVER_VCP;
2670 output[0x01] &= ~DRIVER_VCP;
2671 if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2672 output[0x01] |= SUSPEND_DBUS7_BIT;
2674 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2676 if (eeprom->suspend_pull_downs == 1)
2677 output[0x0A] |= 0x4;
2679 output[0x0A] &= ~0x4;
2681 if (eeprom->group0_drive > DRIVE_16MA)
2682 output[0x0c] |= DRIVE_16MA;
2684 output[0x0c] |= eeprom->group0_drive;
2685 if (eeprom->group0_schmitt == IS_SCHMITT)
2686 output[0x0c] |= IS_SCHMITT;
2687 if (eeprom->group0_slew == SLOW_SLEW)
2688 output[0x0c] |= SLOW_SLEW;
2690 if (eeprom->group1_drive > DRIVE_16MA)
2691 output[0x0c] |= DRIVE_16MA<<4;
2693 output[0x0c] |= eeprom->group1_drive<<4;
2694 if (eeprom->group1_schmitt == IS_SCHMITT)
2695 output[0x0c] |= IS_SCHMITT<<4;
2696 if (eeprom->group1_slew == SLOW_SLEW)
2697 output[0x0c] |= SLOW_SLEW<<4;
2699 if (eeprom->group2_drive > DRIVE_16MA)
2700 output[0x0d] |= DRIVE_16MA;
2702 output[0x0d] |= eeprom->group2_drive;
2703 if (eeprom->group2_schmitt == IS_SCHMITT)
2704 output[0x0d] |= IS_SCHMITT;
2705 if (eeprom->group2_slew == SLOW_SLEW)
2706 output[0x0d] |= SLOW_SLEW;
2708 if (eeprom->group3_drive > DRIVE_16MA)
2709 output[0x0d] |= DRIVE_16MA<<4;
2711 output[0x0d] |= eeprom->group3_drive<<4;
2712 if (eeprom->group3_schmitt == IS_SCHMITT)
2713 output[0x0d] |= IS_SCHMITT<<4;
2714 if (eeprom->group3_slew == SLOW_SLEW)
2715 output[0x0d] |= SLOW_SLEW<<4;
2717 output[0x18] = eeprom->chip;
2721 output[0x18] = eeprom->chip;
2722 fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2725 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H);
2726 if ( eeprom->channel_a_driver == DRIVER_VCP)
2727 output[0x00] |= DRIVER_VCPH;
2729 output[0x00] &= ~DRIVER_VCPH;
2730 if (eeprom->powersave)
2731 output[0x01] |= POWER_SAVE_DISABLE_H;
2733 output[0x01] &= ~POWER_SAVE_DISABLE_H;
2734 if (eeprom->clock_polarity)
2735 output[0x01] |= FT1284_CLK_IDLE_STATE;
2737 output[0x01] &= ~FT1284_CLK_IDLE_STATE;
2738 if (eeprom->data_order)
2739 output[0x01] |= FT1284_DATA_LSB;
2741 output[0x01] &= ~FT1284_DATA_LSB;
2742 if (eeprom->flow_control)
2743 output[0x01] |= FT1284_FLOW_CONTROL;
2745 output[0x01] &= ~FT1284_FLOW_CONTROL;
2746 if (eeprom->group0_drive > DRIVE_16MA)
2747 output[0x0c] |= DRIVE_16MA;
2749 output[0x0c] |= eeprom->group0_drive;
2750 if (eeprom->group0_schmitt == IS_SCHMITT)
2751 output[0x0c] |= IS_SCHMITT;
2752 if (eeprom->group0_slew == SLOW_SLEW)
2753 output[0x0c] |= SLOW_SLEW;
2755 if (eeprom->group1_drive > DRIVE_16MA)
2756 output[0x0d] |= DRIVE_16MA;
2758 output[0x0d] |= eeprom->group1_drive;
2759 if (eeprom->group1_schmitt == IS_SCHMITT)
2760 output[0x0d] |= IS_SCHMITT;
2761 if (eeprom->group1_slew == SLOW_SLEW)
2762 output[0x0d] |= SLOW_SLEW;
2764 set_ft232h_cbus(eeprom, output);
2766 output[0x1e] = eeprom->chip;
2767 fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
2772 // calculate checksum
2775 for (i = 0; i < eeprom->size/2-1; i++)
2777 value = output[i*2];
2778 value += output[(i*2)+1] << 8;
2780 checksum = value^checksum;
2781 checksum = (checksum << 1) | (checksum >> 15);
2784 output[eeprom->size-2] = checksum;
2785 output[eeprom->size-1] = checksum >> 8;
2787 return user_area_size;
2789 /* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
2792 * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
2794 static unsigned char bit2type(unsigned char bits)
2798 case 0: return CHANNEL_IS_UART;
2799 case 1: return CHANNEL_IS_FIFO;
2800 case 2: return CHANNEL_IS_OPTO;
2801 case 4: return CHANNEL_IS_CPU;
2802 case 8: return CHANNEL_IS_FT1284;
2804 fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
2810 Decode binary EEPROM image into an ftdi_eeprom structure.
2812 \param ftdi pointer to ftdi_context
2813 \param verbose Decode EEPROM on stdout
2816 \retval -1: something went wrong
2818 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2819 FIXME: Strings are malloc'ed here and should be freed somewhere
2821 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2824 unsigned short checksum, eeprom_checksum, value;
2825 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2827 struct ftdi_eeprom *eeprom;
2828 unsigned char *buf = ftdi->eeprom->buf;
2832 ftdi_error_return(-1,"No context");
2833 if (ftdi->eeprom == NULL)
2834 ftdi_error_return(-1,"No eeprom structure");
2836 eeprom = ftdi->eeprom;
2837 eeprom_size = eeprom->size;
2839 // Addr 02: Vendor ID
2840 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2842 // Addr 04: Product ID
2843 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2845 release = buf[0x06] + (buf[0x07]<<8);
2847 // Addr 08: Config descriptor
2849 // Bit 6: 1 if this device is self powered, 0 if bus powered
2850 // Bit 5: 1 if this device uses remote wakeup
2851 eeprom->self_powered = buf[0x08] & 0x40;
2852 eeprom->remote_wakeup = buf[0x08] & 0x20;
2854 // Addr 09: Max power consumption: max power = value * 2 mA
2855 eeprom->max_power = buf[0x09];
2857 // Addr 0A: Chip configuration
2858 // Bit 7: 0 - reserved
2859 // Bit 6: 0 - reserved
2860 // Bit 5: 0 - reserved
2861 // Bit 4: 1 - Change USB version on BM and 2232C
2862 // Bit 3: 1 - Use the serial number string
2863 // Bit 2: 1 - Enable suspend pull downs for lower power
2864 // Bit 1: 1 - Out EndPoint is Isochronous
2865 // Bit 0: 1 - In EndPoint is Isochronous
2867 eeprom->in_is_isochronous = buf[0x0A]&0x01;
2868 eeprom->out_is_isochronous = buf[0x0A]&0x02;
2869 eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2870 eeprom->use_serial = buf[0x0A] & USE_SERIAL_NUM;
2871 eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT;
2873 // Addr 0C: USB version low byte when 0x0A
2874 // Addr 0D: USB version high byte when 0x0A
2875 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2877 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2878 // Addr 0F: Length of manufacturer string
2879 manufacturer_size = buf[0x0F]/2;
2880 if (eeprom->manufacturer)
2881 free(eeprom->manufacturer);
2882 if (manufacturer_size > 0)
2884 eeprom->manufacturer = malloc(manufacturer_size);
2885 if (eeprom->manufacturer)
2887 // Decode manufacturer
2888 i = buf[0x0E] & (eeprom_size -1); // offset
2889 for (j=0;j<manufacturer_size-1;j++)
2891 eeprom->manufacturer[j] = buf[2*j+i+2];
2893 eeprom->manufacturer[j] = '\0';
2896 else eeprom->manufacturer = NULL;
2898 // Addr 10: Offset of the product string + 0x80, calculated later
2899 // Addr 11: Length of product string
2900 if (eeprom->product)
2901 free(eeprom->product);
2902 product_size = buf[0x11]/2;
2903 if (product_size > 0)
2905 eeprom->product = malloc(product_size);
2906 if (eeprom->product)
2908 // Decode product name
2909 i = buf[0x10] & (eeprom_size -1); // offset
2910 for (j=0;j<product_size-1;j++)
2912 eeprom->product[j] = buf[2*j+i+2];
2914 eeprom->product[j] = '\0';
2917 else eeprom->product = NULL;
2919 // Addr 12: Offset of the serial string + 0x80, calculated later
2920 // Addr 13: Length of serial string
2922 free(eeprom->serial);
2923 serial_size = buf[0x13]/2;
2924 if (serial_size > 0)
2926 eeprom->serial = malloc(serial_size);
2930 i = buf[0x12] & (eeprom_size -1); // offset
2931 for (j=0;j<serial_size-1;j++)
2933 eeprom->serial[j] = buf[2*j+i+2];
2935 eeprom->serial[j] = '\0';
2938 else eeprom->serial = NULL;
2943 for (i = 0; i < eeprom_size/2-1; i++)
2946 value += buf[(i*2)+1] << 8;
2948 checksum = value^checksum;
2949 checksum = (checksum << 1) | (checksum >> 15);
2952 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2954 if (eeprom_checksum != checksum)
2956 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2957 ftdi_error_return(-1,"EEPROM checksum error");
2960 eeprom->channel_a_type = 0;
2961 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2965 else if (ftdi->type == TYPE_2232C)
2967 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2968 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2969 eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
2970 eeprom->channel_b_type = buf[0x01] & 0x7;
2971 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2972 eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
2973 eeprom->chip = buf[0x14];
2975 else if (ftdi->type == TYPE_R)
2977 /* TYPE_R flags D2XX, not VCP as all others*/
2978 eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2979 eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2980 if ( (buf[0x01]&0x40) != 0x40)
2982 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2983 " If this happened with the\n"
2984 " EEPROM programmed by FTDI tools, please report "
2985 "to libftdi@developer.intra2net.com\n");
2987 eeprom->chip = buf[0x16];
2988 // Addr 0B: Invert data lines
2989 // Works only on FT232R, not FT245R, but no way to distinguish
2990 eeprom->invert = buf[0x0B];
2991 // Addr 14: CBUS function: CBUS0, CBUS1
2992 // Addr 15: CBUS function: CBUS2, CBUS3
2993 // Addr 16: CBUS function: CBUS5
2994 eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2995 eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2996 eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2997 eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2998 eeprom->cbus_function[4] = buf[0x16] & 0x0f;
3000 else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
3002 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3003 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3004 eeprom->channel_b_type = bit2type(buf[0x01] & 0x7);
3005 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3007 if (ftdi->type == TYPE_2232H)
3008 eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
3010 eeprom->chip = buf[0x18];
3011 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3012 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3013 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3014 eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
3015 eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3016 eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3017 eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
3018 eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
3019 eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
3020 eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
3021 eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3022 eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
3024 else if (ftdi->type == TYPE_232H)
3028 eeprom->channel_a_type = buf[0x00] & 0xf;
3029 eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
3030 eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
3031 eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
3032 eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
3033 eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
3034 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3035 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3036 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3037 eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
3038 eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
3039 eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
3043 eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
3044 eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3046 eeprom->chip = buf[0x1e];
3047 /*FIXME: Decipher more values*/
3052 char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
3053 fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
3054 fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
3055 fprintf(stdout, "Release: 0x%04x\n",release);
3057 if (eeprom->self_powered)
3058 fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3060 fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
3061 (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3062 if (eeprom->manufacturer)
3063 fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3064 if (eeprom->product)
3065 fprintf(stdout, "Product: %s\n",eeprom->product);
3067 fprintf(stdout, "Serial: %s\n",eeprom->serial);
3068 fprintf(stdout, "Checksum : %04x\n", checksum);
3069 if (ftdi->type == TYPE_R)
3070 fprintf(stdout, "Internal EEPROM\n");
3071 else if (eeprom->chip >= 0x46)
3072 fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
3073 if (eeprom->suspend_dbus7)
3074 fprintf(stdout, "Suspend on DBUS7\n");
3075 if (eeprom->suspend_pull_downs)
3076 fprintf(stdout, "Pull IO pins low during suspend\n");
3077 if(eeprom->powersave)
3079 if(ftdi->type >= TYPE_232H)
3080 fprintf(stdout,"Enter low power state on ACBUS7\n");
3082 if (eeprom->remote_wakeup)
3083 fprintf(stdout, "Enable Remote Wake Up\n");
3084 fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3085 if (ftdi->type >= TYPE_2232C)
3086 fprintf(stdout,"Channel A has Mode %s%s%s\n",
3087 channel_mode[eeprom->channel_a_type],
3088 (eeprom->channel_a_driver)?" VCP":"",
3089 (eeprom->high_current_a)?" High Current IO":"");
3090 if (ftdi->type >= TYPE_232H)
3092 fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3093 (eeprom->clock_polarity)?"HIGH":"LOW",
3094 (eeprom->data_order)?"LSB":"MSB",
3095 (eeprom->flow_control)?"":"No ");
3097 if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
3098 fprintf(stdout,"Channel B has Mode %s%s%s\n",
3099 channel_mode[eeprom->channel_b_type],
3100 (eeprom->channel_b_driver)?" VCP":"",
3101 (eeprom->high_current_b)?" High Current IO":"");
3102 if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3103 eeprom->use_usb_version == USE_USB_VERSION_BIT)
3104 fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3106 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3108 fprintf(stdout,"%s has %d mA drive%s%s\n",
3109 (ftdi->type == TYPE_2232H)?"AL":"A",
3110 (eeprom->group0_drive+1) *4,
3111 (eeprom->group0_schmitt)?" Schmitt Input":"",
3112 (eeprom->group0_slew)?" Slow Slew":"");
3113 fprintf(stdout,"%s has %d mA drive%s%s\n",
3114 (ftdi->type == TYPE_2232H)?"AH":"B",
3115 (eeprom->group1_drive+1) *4,
3116 (eeprom->group1_schmitt)?" Schmitt Input":"",
3117 (eeprom->group1_slew)?" Slow Slew":"");
3118 fprintf(stdout,"%s has %d mA drive%s%s\n",
3119 (ftdi->type == TYPE_2232H)?"BL":"C",
3120 (eeprom->group2_drive+1) *4,
3121 (eeprom->group2_schmitt)?" Schmitt Input":"",
3122 (eeprom->group2_slew)?" Slow Slew":"");
3123 fprintf(stdout,"%s has %d mA drive%s%s\n",
3124 (ftdi->type == TYPE_2232H)?"BH":"D",
3125 (eeprom->group3_drive+1) *4,
3126 (eeprom->group3_schmitt)?" Schmitt Input":"",
3127 (eeprom->group3_slew)?" Slow Slew":"");
3129 else if (ftdi->type == TYPE_232H)
3132 char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3133 "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3134 "CLK30","CLK15","CLK7_5"
3136 fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3137 (eeprom->group0_drive+1) *4,
3138 (eeprom->group0_schmitt)?" Schmitt Input":"",
3139 (eeprom->group0_slew)?" Slow Slew":"");
3140 fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3141 (eeprom->group1_drive+1) *4,
3142 (eeprom->group1_schmitt)?" Schmitt Input":"",
3143 (eeprom->group1_slew)?" Slow Slew":"");
3144 for (i=0; i<10; i++)
3146 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3147 fprintf(stdout,"C%d Function: %s\n", i,
3148 cbush_mux[eeprom->cbus_function[i]]);
3153 if (ftdi->type == TYPE_R)
3155 char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3156 "SLEEP","CLK48","CLK24","CLK12","CLK6",
3157 "IOMODE","BB_WR","BB_RD"
3159 char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3163 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
3164 fprintf(stdout,"Inverted bits:");
3166 if ((eeprom->invert & (1<<i)) == (1<<i))
3167 fprintf(stdout," %s",r_bits[i]);
3168 fprintf(stdout,"\n");
3172 if (eeprom->cbus_function[i]<CBUS_BB)
3173 fprintf(stdout,"C%d Function: %s\n", i,
3174 cbus_mux[eeprom->cbus_function[i]]);
3178 /* Running MPROG show that C0..3 have fixed function Synchronous
3180 fprintf(stdout,"C%d BB Function: %s\n", i,
3183 fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3192 Get a value from the decoded EEPROM structure
3194 \param ftdi pointer to ftdi_context
3195 \param value_name Enum of the value to query
3196 \param value Pointer to store read value
3199 \retval -1: Value doesn't exist
3201 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3206 *value = ftdi->eeprom->vendor_id;
3209 *value = ftdi->eeprom->product_id;
3212 *value = ftdi->eeprom->self_powered;
3215 *value = ftdi->eeprom->remote_wakeup;
3218 *value = ftdi->eeprom->is_not_pnp;
3221 *value = ftdi->eeprom->suspend_dbus7;
3223 case IN_IS_ISOCHRONOUS:
3224 *value = ftdi->eeprom->in_is_isochronous;
3226 case OUT_IS_ISOCHRONOUS:
3227 *value = ftdi->eeprom->out_is_isochronous;
3229 case SUSPEND_PULL_DOWNS:
3230 *value = ftdi->eeprom->suspend_pull_downs;
3233 *value = ftdi->eeprom->use_serial;
3236 *value = ftdi->eeprom->usb_version;
3238 case USE_USB_VERSION:
3239 *value = ftdi->eeprom->use_usb_version;
3242 *value = ftdi->eeprom->max_power;
3244 case CHANNEL_A_TYPE:
3245 *value = ftdi->eeprom->channel_a_type;
3247 case CHANNEL_B_TYPE:
3248 *value = ftdi->eeprom->channel_b_type;
3250 case CHANNEL_A_DRIVER:
3251 *value = ftdi->eeprom->channel_a_driver;
3253 case CHANNEL_B_DRIVER:
3254 *value = ftdi->eeprom->channel_b_driver;
3256 case CBUS_FUNCTION_0:
3257 *value = ftdi->eeprom->cbus_function[0];
3259 case CBUS_FUNCTION_1:
3260 *value = ftdi->eeprom->cbus_function[1];
3262 case CBUS_FUNCTION_2:
3263 *value = ftdi->eeprom->cbus_function[2];
3265 case CBUS_FUNCTION_3:
3266 *value = ftdi->eeprom->cbus_function[3];
3268 case CBUS_FUNCTION_4:
3269 *value = ftdi->eeprom->cbus_function[4];
3271 case CBUS_FUNCTION_5:
3272 *value = ftdi->eeprom->cbus_function[5];
3274 case CBUS_FUNCTION_6:
3275 *value = ftdi->eeprom->cbus_function[6];
3277 case CBUS_FUNCTION_7:
3278 *value = ftdi->eeprom->cbus_function[7];
3280 case CBUS_FUNCTION_8:
3281 *value = ftdi->eeprom->cbus_function[8];
3283 case CBUS_FUNCTION_9:
3284 *value = ftdi->eeprom->cbus_function[8];
3287 *value = ftdi->eeprom->high_current;
3289 case HIGH_CURRENT_A:
3290 *value = ftdi->eeprom->high_current_a;
3292 case HIGH_CURRENT_B:
3293 *value = ftdi->eeprom->high_current_b;
3296 *value = ftdi->eeprom->invert;
3299 *value = ftdi->eeprom->group0_drive;
3301 case GROUP0_SCHMITT:
3302 *value = ftdi->eeprom->group0_schmitt;
3305 *value = ftdi->eeprom->group0_slew;
3308 *value = ftdi->eeprom->group1_drive;
3310 case GROUP1_SCHMITT:
3311 *value = ftdi->eeprom->group1_schmitt;
3314 *value = ftdi->eeprom->group1_slew;
3317 *value = ftdi->eeprom->group2_drive;
3319 case GROUP2_SCHMITT:
3320 *value = ftdi->eeprom->group2_schmitt;
3323 *value = ftdi->eeprom->group2_slew;
3326 *value = ftdi->eeprom->group3_drive;
3328 case GROUP3_SCHMITT:
3329 *value = ftdi->eeprom->group3_schmitt;
3332 *value = ftdi->eeprom->group3_slew;
3335 *value = ftdi->eeprom->powersave;
3337 case CLOCK_POLARITY:
3338 *value = ftdi->eeprom->clock_polarity;
3341 *value = ftdi->eeprom->data_order;
3344 *value = ftdi->eeprom->flow_control;
3347 *value = ftdi->eeprom->chip;
3350 *value = ftdi->eeprom->size;
3353 ftdi_error_return(-1, "Request for unknown EEPROM value");
3359 Set a value in the decoded EEPROM Structure
3360 No parameter checking is performed
3362 \param ftdi pointer to ftdi_context
3363 \param value_name Enum of the value to set
3367 \retval -1: Value doesn't exist
3368 \retval -2: Value not user settable
3370 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3375 ftdi->eeprom->vendor_id = value;
3378 ftdi->eeprom->product_id = value;
3381 ftdi->eeprom->self_powered = value;
3384 ftdi->eeprom->remote_wakeup = value;
3387 ftdi->eeprom->is_not_pnp = value;
3390 ftdi->eeprom->suspend_dbus7 = value;
3392 case IN_IS_ISOCHRONOUS:
3393 ftdi->eeprom->in_is_isochronous = value;
3395 case OUT_IS_ISOCHRONOUS:
3396 ftdi->eeprom->out_is_isochronous = value;
3398 case SUSPEND_PULL_DOWNS:
3399 ftdi->eeprom->suspend_pull_downs = value;
3402 ftdi->eeprom->use_serial = value;
3405 ftdi->eeprom->usb_version = value;
3407 case USE_USB_VERSION:
3408 ftdi->eeprom->use_usb_version = value;
3411 ftdi->eeprom->max_power = value;
3413 case CHANNEL_A_TYPE:
3414 ftdi->eeprom->channel_a_type = value;
3416 case CHANNEL_B_TYPE:
3417 ftdi->eeprom->channel_b_type = value;
3419 case CHANNEL_A_DRIVER:
3420 ftdi->eeprom->channel_a_driver = value;
3422 case CHANNEL_B_DRIVER:
3423 ftdi->eeprom->channel_b_driver = value;
3425 case CBUS_FUNCTION_0:
3426 ftdi->eeprom->cbus_function[0] = value;
3428 case CBUS_FUNCTION_1:
3429 ftdi->eeprom->cbus_function[1] = value;
3431 case CBUS_FUNCTION_2:
3432 ftdi->eeprom->cbus_function[2] = value;
3434 case CBUS_FUNCTION_3:
3435 ftdi->eeprom->cbus_function[3] = value;
3437 case CBUS_FUNCTION_4:
3438 ftdi->eeprom->cbus_function[4] = value;
3440 case CBUS_FUNCTION_5:
3441 ftdi->eeprom->cbus_function[5] = value;
3443 case CBUS_FUNCTION_6:
3444 ftdi->eeprom->cbus_function[6] = value;
3446 case CBUS_FUNCTION_7:
3447 ftdi->eeprom->cbus_function[7] = value;
3449 case CBUS_FUNCTION_8:
3450 ftdi->eeprom->cbus_function[8] = value;
3452 case CBUS_FUNCTION_9:
3453 ftdi->eeprom->cbus_function[9] = value;
3456 ftdi->eeprom->high_current = value;
3458 case HIGH_CURRENT_A:
3459 ftdi->eeprom->high_current_a = value;
3461 case HIGH_CURRENT_B:
3462 ftdi->eeprom->high_current_b = value;
3465 ftdi->eeprom->invert = value;
3468 ftdi->eeprom->group0_drive = value;
3470 case GROUP0_SCHMITT:
3471 ftdi->eeprom->group0_schmitt = value;
3474 ftdi->eeprom->group0_slew = value;
3477 ftdi->eeprom->group1_drive = value;
3479 case GROUP1_SCHMITT:
3480 ftdi->eeprom->group1_schmitt = value;
3483 ftdi->eeprom->group1_slew = value;
3486 ftdi->eeprom->group2_drive = value;
3488 case GROUP2_SCHMITT:
3489 ftdi->eeprom->group2_schmitt = value;
3492 ftdi->eeprom->group2_slew = value;
3495 ftdi->eeprom->group3_drive = value;
3497 case GROUP3_SCHMITT:
3498 ftdi->eeprom->group3_schmitt = value;
3501 ftdi->eeprom->group3_slew = value;
3504 ftdi->eeprom->chip = value;
3507 ftdi->eeprom->powersave = value;
3509 case CLOCK_POLARITY:
3510 ftdi->eeprom->clock_polarity = value;
3513 ftdi->eeprom->data_order = value;
3516 ftdi->eeprom->flow_control = value;
3519 ftdi_error_return(-2, "EEPROM Value can't be changed");
3521 ftdi_error_return(-1, "Request to unknown EEPROM value");
3526 /** Get the read-only buffer to the binary EEPROM content
3528 \param ftdi pointer to ftdi_context
3529 \param buf buffer to receive EEPROM content
3530 \param size Size of receiving buffer
3533 \retval -1: struct ftdi_contxt or ftdi_eeprom missing
3534 \retval -2: Not enough room to store eeprom
3536 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3538 if (!ftdi || !(ftdi->eeprom))
3539 ftdi_error_return(-1, "No appropriate structure");
3541 if (!buf || size < ftdi->eeprom->size)
3542 ftdi_error_return(-1, "Not enough room to store eeprom");
3544 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3545 if (size > FTDI_MAX_EEPROM_SIZE)
3546 size = FTDI_MAX_EEPROM_SIZE;
3548 memcpy(buf, ftdi->eeprom->buf, size);
3553 /** Set the EEPROM content from the user-supplied prefilled buffer
3555 \param ftdi pointer to ftdi_context
3556 \param buf buffer to read EEPROM content
3557 \param size Size of buffer
3560 \retval -1: struct ftdi_contxt or ftdi_eeprom of buf missing
3562 int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
3564 if (!ftdi || !(ftdi->eeprom) || !buf)
3565 ftdi_error_return(-1, "No appropriate structure");
3567 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3568 if (size > FTDI_MAX_EEPROM_SIZE)
3569 size = FTDI_MAX_EEPROM_SIZE;
3571 memcpy(ftdi->eeprom->buf, buf, size);
3577 Read eeprom location
3579 \param ftdi pointer to ftdi_context
3580 \param eeprom_addr Address of eeprom location to be read
3581 \param eeprom_val Pointer to store read eeprom location
3584 \retval -1: read failed
3585 \retval -2: USB device unavailable
3587 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3589 if (ftdi == NULL || ftdi->usb_dev == NULL)
3590 ftdi_error_return(-2, "USB device unavailable");
3592 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)
3593 ftdi_error_return(-1, "reading eeprom failed");
3601 \param ftdi pointer to ftdi_context
3604 \retval -1: read failed
3605 \retval -2: USB device unavailable
3607 int ftdi_read_eeprom(struct ftdi_context *ftdi)
3612 if (ftdi == NULL || ftdi->usb_dev == NULL)
3613 ftdi_error_return(-2, "USB device unavailable");
3614 buf = ftdi->eeprom->buf;
3616 for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3618 if (libusb_control_transfer(
3619 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3620 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3621 ftdi_error_return(-1, "reading eeprom failed");
3624 if (ftdi->type == TYPE_R)
3625 ftdi->eeprom->size = 0x80;
3626 /* Guesses size of eeprom by comparing halves
3627 - will not work with blank eeprom */
3628 else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3629 ftdi->eeprom->size = -1;
3630 else if (memcmp(buf,&buf[0x80],0x80) == 0)
3631 ftdi->eeprom->size = 0x80;
3632 else if (memcmp(buf,&buf[0x40],0x40) == 0)
3633 ftdi->eeprom->size = 0x40;
3635 ftdi->eeprom->size = 0x100;
3640 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3641 Function is only used internally
3644 static unsigned char ftdi_read_chipid_shift(unsigned char value)
3646 return ((value & 1) << 1) |
3647 ((value & 2) << 5) |
3648 ((value & 4) >> 2) |
3649 ((value & 8) << 4) |
3650 ((value & 16) >> 1) |
3651 ((value & 32) >> 1) |
3652 ((value & 64) >> 4) |
3653 ((value & 128) >> 2);
3657 Read the FTDIChip-ID from R-type devices
3659 \param ftdi pointer to ftdi_context
3660 \param chipid Pointer to store FTDIChip-ID
3663 \retval -1: read failed
3664 \retval -2: USB device unavailable
3666 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3668 unsigned int a = 0, b = 0;
3670 if (ftdi == NULL || ftdi->usb_dev == NULL)
3671 ftdi_error_return(-2, "USB device unavailable");
3673 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)
3675 a = a << 8 | a >> 8;
3676 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)
3678 b = b << 8 | b >> 8;
3679 a = (a << 16) | (b & 0xFFFF);
3680 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3681 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3682 *chipid = a ^ 0xa5f0f7d1;
3687 ftdi_error_return(-1, "read of FTDIChip-ID failed");
3691 Write eeprom location
3693 \param ftdi pointer to ftdi_context
3694 \param eeprom_addr Address of eeprom location to be written
3695 \param eeprom_val Value to be written
3698 \retval -1: write failed
3699 \retval -2: USB device unavailable
3700 \retval -3: Invalid access to checksum protected area below 0x80
3701 \retval -4: Device can't access unprotected area
3702 \retval -5: Reading chip type failed
3704 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3705 unsigned short eeprom_val)
3707 int chip_type_location;
3708 unsigned short chip_type;
3710 if (ftdi == NULL || ftdi->usb_dev == NULL)
3711 ftdi_error_return(-2, "USB device unavailable");
3713 if (eeprom_addr <0x80)
3714 ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
3721 chip_type_location = 0x14;
3725 chip_type_location = 0x18;
3728 chip_type_location = 0x1e;
3731 ftdi_error_return(-4, "Device can't access unprotected area");
3734 if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3735 ftdi_error_return(-5, "Reading failed failed");
3736 fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3737 if ((chip_type & 0xff) != 0x66)
3739 ftdi_error_return(-6, "EEPROM is not of 93x66");
3742 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3743 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3744 NULL, 0, ftdi->usb_write_timeout) != 0)
3745 ftdi_error_return(-1, "unable to write eeprom");
3753 \param ftdi pointer to ftdi_context
3756 \retval -1: read failed
3757 \retval -2: USB device unavailable
3759 int ftdi_write_eeprom(struct ftdi_context *ftdi)
3761 unsigned short usb_val, status;
3763 unsigned char *eeprom;
3765 if (ftdi == NULL || ftdi->usb_dev == NULL)
3766 ftdi_error_return(-2, "USB device unavailable");
3767 eeprom = ftdi->eeprom->buf;
3769 /* These commands were traced while running MProg */
3770 if ((ret = ftdi_usb_reset(ftdi)) != 0)
3772 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3774 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3777 for (i = 0; i < ftdi->eeprom->size/2; i++)
3779 usb_val = eeprom[i*2];
3780 usb_val += eeprom[(i*2)+1] << 8;
3781 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3782 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3783 NULL, 0, ftdi->usb_write_timeout) < 0)
3784 ftdi_error_return(-1, "unable to write eeprom");
3793 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3795 \param ftdi pointer to ftdi_context
3798 \retval -1: erase failed
3799 \retval -2: USB device unavailable
3800 \retval -3: Writing magic failed
3801 \retval -4: Read EEPROM failed
3802 \retval -5: Unexpected EEPROM value
3804 #define MAGIC 0x55aa
3805 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3807 unsigned short eeprom_value;
3808 if (ftdi == NULL || ftdi->usb_dev == NULL)
3809 ftdi_error_return(-2, "USB device unavailable");
3811 if (ftdi->type == TYPE_R)
3813 ftdi->eeprom->chip = 0;
3817 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3818 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3819 ftdi_error_return(-1, "unable to erase eeprom");
3822 /* detect chip type by writing 0x55AA as magic at word position 0xc0
3823 Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3824 Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3825 Chip is 93x66 if magic is only read at word position 0xc0*/
3826 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3827 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3828 NULL, 0, ftdi->usb_write_timeout) != 0)
3829 ftdi_error_return(-3, "Writing magic failed");
3830 if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3831 ftdi_error_return(-4, "Reading failed failed");
3832 if (eeprom_value == MAGIC)
3834 ftdi->eeprom->chip = 0x46;
3838 if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3839 ftdi_error_return(-4, "Reading failed failed");
3840 if (eeprom_value == MAGIC)
3841 ftdi->eeprom->chip = 0x56;
3844 if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3845 ftdi_error_return(-4, "Reading failed failed");
3846 if (eeprom_value == MAGIC)
3847 ftdi->eeprom->chip = 0x66;
3850 ftdi->eeprom->chip = -1;
3854 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3855 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3856 ftdi_error_return(-1, "unable to erase eeprom");
3861 Get string representation for last error code
3863 \param ftdi pointer to ftdi_context
3865 \retval Pointer to error string
3867 char *ftdi_get_error_string (struct ftdi_context *ftdi)
3872 return ftdi->error_str;
3875 /* @} end of doxygen libftdi group */