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