1 /***************************************************************************
5 copyright : (C) 2003-2010 by Intra2net AG
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; \
46 Internal function to close usb device pointer.
47 Sets ftdi->usb_dev to NULL.
50 \param ftdi pointer to ftdi_context
54 static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
56 if (ftdi && ftdi->usb_dev)
58 libusb_close (ftdi->usb_dev);
64 Initializes a ftdi_context.
66 \param ftdi pointer to ftdi_context
69 \retval -1: couldn't allocate read buffer
71 \remark This should be called before all functions
73 int ftdi_init(struct ftdi_context *ftdi)
76 ftdi->usb_read_timeout = 5000;
77 ftdi->usb_write_timeout = 5000;
79 ftdi->type = TYPE_BM; /* chip type */
81 ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
83 ftdi->readbuffer = NULL;
84 ftdi->readbuffer_offset = 0;
85 ftdi->readbuffer_remaining = 0;
86 ftdi->writebuffer_chunksize = 4096;
87 ftdi->max_packet_size = 0;
93 ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
95 ftdi->error_str = NULL;
97 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
99 /* All fine. Now allocate the readbuffer */
100 return ftdi_read_data_set_chunksize(ftdi, 4096);
104 Allocate and initialize a new ftdi_context
106 \return a pointer to a new ftdi_context, or NULL on failure
108 struct ftdi_context *ftdi_new(void)
110 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
117 if (ftdi_init(ftdi) != 0)
127 Open selected channels on a chip, otherwise use first channel.
129 \param ftdi pointer to ftdi_context
130 \param interface Interface to use for FT2232C/2232H/4232H chips.
133 \retval -1: unknown interface
134 \retval -2: USB device unavailable
136 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
138 if (ftdi == NULL || ftdi->usb_dev == NULL)
139 ftdi_error_return(-2, "USB device unavailable");
145 /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
149 ftdi->index = INTERFACE_B;
155 ftdi->index = INTERFACE_C;
161 ftdi->index = INTERFACE_D;
166 ftdi_error_return(-1, "Unknown interface");
172 Deinitializes a ftdi_context.
174 \param ftdi pointer to ftdi_context
176 void ftdi_deinit(struct ftdi_context *ftdi)
181 ftdi_usb_close_internal (ftdi);
183 if (ftdi->readbuffer != NULL)
185 free(ftdi->readbuffer);
186 ftdi->readbuffer = NULL;
191 Deinitialize and free an ftdi_context.
193 \param ftdi pointer to ftdi_context
195 void ftdi_free(struct ftdi_context *ftdi)
202 Use an already open libusb device.
204 \param ftdi pointer to ftdi_context
205 \param usb libusb libusb_device_handle to use
207 void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
217 Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
218 needs to be deallocated by ftdi_list_free() after use.
220 \param ftdi pointer to ftdi_context
221 \param devlist Pointer where to store list of found devices
222 \param vendor Vendor ID to search for
223 \param product Product ID to search for
225 \retval >0: number of devices found
226 \retval -3: out of memory
227 \retval -4: libusb_init() failed
228 \retval -5: libusb_get_device_list() failed
229 \retval -6: libusb_get_device_descriptor() failed
231 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
233 struct ftdi_device_list **curdev;
235 libusb_device **devs;
239 if (libusb_init(NULL) < 0)
240 ftdi_error_return(-4, "libusb_init() failed");
242 if (libusb_get_device_list(NULL, &devs) < 0)
243 ftdi_error_return(-5, "libusb_get_device_list() failed");
248 while ((dev = devs[i++]) != NULL)
250 struct libusb_device_descriptor desc;
252 if (libusb_get_device_descriptor(dev, &desc) < 0)
253 ftdi_error_return(-6, "libusb_get_device_descriptor() failed");
255 if (desc.idVendor == vendor && desc.idProduct == product)
257 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
259 ftdi_error_return(-3, "out of memory");
261 (*curdev)->next = NULL;
262 (*curdev)->dev = dev;
264 curdev = &(*curdev)->next;
273 Frees a usb device list.
275 \param devlist USB device list created by ftdi_usb_find_all()
277 void ftdi_list_free(struct ftdi_device_list **devlist)
279 struct ftdi_device_list *curdev, *next;
281 for (curdev = *devlist; curdev != NULL;)
292 Frees a usb device list.
294 \param devlist USB device list created by ftdi_usb_find_all()
296 void ftdi_list_free2(struct ftdi_device_list *devlist)
298 ftdi_list_free(&devlist);
302 Return device ID strings from the usb device.
304 The parameters manufacturer, description and serial may be NULL
305 or pointer to buffers to store the fetched strings.
307 \note Use this function only in combination with ftdi_usb_find_all()
308 as it closes the internal "usb_dev" after use.
310 \param ftdi pointer to ftdi_context
311 \param dev libusb usb_dev to use
312 \param manufacturer Store manufacturer string here if not NULL
313 \param mnf_len Buffer size of manufacturer string
314 \param description Store product description string here if not NULL
315 \param desc_len Buffer size of product description string
316 \param serial Store serial string here if not NULL
317 \param serial_len Buffer size of serial string
320 \retval -1: wrong arguments
321 \retval -4: unable to open device
322 \retval -7: get product manufacturer failed
323 \retval -8: get product description failed
324 \retval -9: get serial number failed
325 \retval -11: libusb_get_device_descriptor() failed
327 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
328 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
330 struct libusb_device_descriptor desc;
332 if ((ftdi==NULL) || (dev==NULL))
335 if (libusb_open(dev, &ftdi->usb_dev) < 0)
336 ftdi_error_return(-4, "libusb_open() failed");
338 if (libusb_get_device_descriptor(dev, &desc) < 0)
339 ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
341 if (manufacturer != NULL)
343 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
345 ftdi_usb_close_internal (ftdi);
346 ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
350 if (description != NULL)
352 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
354 ftdi_usb_close_internal (ftdi);
355 ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
361 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
363 ftdi_usb_close_internal (ftdi);
364 ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
368 ftdi_usb_close_internal (ftdi);
374 * Internal function to determine the maximum packet size.
375 * \param ftdi pointer to ftdi_context
376 * \param dev libusb usb_dev to use
377 * \retval Maximum packet size for this device
379 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
381 struct libusb_device_descriptor desc;
382 struct libusb_config_descriptor *config0;
383 unsigned int packet_size;
386 if (ftdi == NULL || dev == NULL)
389 // Determine maximum packet size. Init with default value.
390 // New hi-speed devices from FTDI use a packet size of 512 bytes
391 // but could be connected to a normal speed USB hub -> 64 bytes packet size.
392 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
397 if (libusb_get_device_descriptor(dev, &desc) < 0)
400 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
403 if (desc.bNumConfigurations > 0)
405 if (ftdi->interface < config0->bNumInterfaces)
407 struct libusb_interface interface = config0->interface[ftdi->interface];
408 if (interface.num_altsetting > 0)
410 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
411 if (descriptor.bNumEndpoints > 0)
413 packet_size = descriptor.endpoint[0].wMaxPacketSize;
419 libusb_free_config_descriptor (config0);
424 Opens a ftdi device given by an usb_device.
426 \param ftdi pointer to ftdi_context
427 \param dev libusb usb_dev to use
430 \retval -3: unable to config device
431 \retval -4: unable to open device
432 \retval -5: unable to claim device
433 \retval -6: reset failed
434 \retval -7: set baudrate failed
435 \retval -8: ftdi context invalid
436 \retval -9: libusb_get_device_descriptor() failed
437 \retval -10: libusb_get_config_descriptor() failed
438 \retval -11: libusb_etach_kernel_driver() failed
439 \retval -12: libusb_get_configuration() failed
441 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
443 struct libusb_device_descriptor desc;
444 struct libusb_config_descriptor *config0;
448 ftdi_error_return(-8, "ftdi context invalid");
450 if (libusb_open(dev, &ftdi->usb_dev) < 0)
451 ftdi_error_return(-4, "libusb_open() failed");
453 if (libusb_get_device_descriptor(dev, &desc) < 0)
454 ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
456 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
457 ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
458 cfg0 = config0->bConfigurationValue;
459 libusb_free_config_descriptor (config0);
461 #ifdef LIBUSB_HAS_GET_DRIVER_NP
462 // Try to detach ftdi_sio kernel module.
463 // Returns ENODATA if driver is not loaded.
465 // The return code is kept in a separate variable and only parsed
466 // if usb_set_configuration() or usb_claim_interface() fails as the
467 // detach operation might be denied and everything still works fine.
468 // Likely scenario is a static ftdi_sio kernel module.
469 ret = libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface);
470 if (ret < 0 && ret != LIBUSB_ERROR_NOT_FOUND)
471 ftdi_error_return(-11, "libusb_detach_kernel_driver () failed");
474 if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
475 ftdi_error_return(-12, "libusb_get_configuration () failed");
477 // set configuration (needed especially for windows)
478 // tolerate EBUSY: one device with one configuration, but two interfaces
479 // and libftdi sessions to both interfaces (e.g. FT2232)
480 if (desc.bNumConfigurations > 0 && cfg != cfg0)
482 if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
484 ftdi_usb_close_internal (ftdi);
485 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
489 if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
491 ftdi_usb_close_internal (ftdi);
492 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
495 if (ftdi_usb_reset (ftdi) != 0)
497 ftdi_usb_close_internal (ftdi);
498 ftdi_error_return(-6, "ftdi_usb_reset failed");
501 // Try to guess chip type
502 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
503 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
504 && desc.iSerialNumber == 0))
505 ftdi->type = TYPE_BM;
506 else if (desc.bcdDevice == 0x200)
507 ftdi->type = TYPE_AM;
508 else if (desc.bcdDevice == 0x500)
509 ftdi->type = TYPE_2232C;
510 else if (desc.bcdDevice == 0x600)
512 else if (desc.bcdDevice == 0x700)
513 ftdi->type = TYPE_2232H;
514 else if (desc.bcdDevice == 0x800)
515 ftdi->type = TYPE_4232H;
517 // Set default interface on dual/quad type chips
524 ftdi->index = INTERFACE_A;
530 // Determine maximum packet size
531 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
533 if (ftdi_set_baudrate (ftdi, 9600) != 0)
535 ftdi_usb_close_internal (ftdi);
536 ftdi_error_return(-7, "set baudrate failed");
539 ftdi_error_return(0, "all fine");
543 Opens the first device with a given vendor and product ids.
545 \param ftdi pointer to ftdi_context
546 \param vendor Vendor ID
547 \param product Product ID
549 \retval same as ftdi_usb_open_desc()
551 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
553 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
557 Opens the first device with a given, vendor id, product id,
558 description and serial.
560 \param ftdi pointer to ftdi_context
561 \param vendor Vendor ID
562 \param product Product ID
563 \param description Description to search for. Use NULL if not needed.
564 \param serial Serial to search for. Use NULL if not needed.
567 \retval -3: usb device not found
568 \retval -4: unable to open device
569 \retval -5: unable to claim device
570 \retval -6: reset failed
571 \retval -7: set baudrate failed
572 \retval -8: get product description failed
573 \retval -9: get serial number failed
574 \retval -11: libusb_init() failed
575 \retval -12: libusb_get_device_list() failed
576 \retval -13: libusb_get_device_descriptor() failed
578 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
579 const char* description, const char* serial)
581 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
585 Opens the index-th device with a given, vendor id, product id,
586 description and serial.
588 \param ftdi pointer to ftdi_context
589 \param vendor Vendor ID
590 \param product Product ID
591 \param description Description to search for. Use NULL if not needed.
592 \param serial Serial to search for. Use NULL if not needed.
593 \param index Number of matching device to open if there are more than one, starts with 0.
596 \retval -1: usb_find_busses() failed
597 \retval -2: usb_find_devices() failed
598 \retval -3: usb device not found
599 \retval -4: unable to open device
600 \retval -5: unable to claim device
601 \retval -6: reset failed
602 \retval -7: set baudrate failed
603 \retval -8: get product description failed
604 \retval -9: get serial number failed
605 \retval -10: unable to close device
606 \retval -11: ftdi context invalid
608 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
609 const char* description, const char* serial, unsigned int index)
612 libusb_device **devs;
616 if (libusb_init(NULL) < 0)
617 ftdi_error_return(-11, "libusb_init() failed");
619 if (libusb_get_device_list(NULL, &devs) < 0)
620 ftdi_error_return(-12, "libusb_get_device_list() failed");
623 ftdi_error_return(-11, "ftdi context invalid");
625 while ((dev = devs[i++]) != NULL)
627 struct libusb_device_descriptor desc;
629 if (libusb_get_device_descriptor(dev, &desc) < 0)
630 ftdi_error_return(-13, "libusb_get_device_descriptor() failed");
632 if (desc.idVendor == vendor && desc.idProduct == product)
634 if (libusb_open(dev, &ftdi->usb_dev) < 0)
635 ftdi_error_return(-4, "usb_open() failed");
637 if (description != NULL)
639 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
641 libusb_close (ftdi->usb_dev);
642 ftdi_error_return(-8, "unable to fetch product description");
644 if (strncmp(string, description, sizeof(string)) != 0)
646 libusb_close (ftdi->usb_dev);
652 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
654 ftdi_usb_close_internal (ftdi);
655 ftdi_error_return(-9, "unable to fetch serial number");
657 if (strncmp(string, serial, sizeof(string)) != 0)
659 ftdi_usb_close_internal (ftdi);
664 ftdi_usb_close_internal (ftdi);
672 return ftdi_usb_open_dev(ftdi, dev);
677 ftdi_error_return(-3, "device not found");
681 Opens the ftdi-device described by a description-string.
682 Intended to be used for parsing a device-description given as commandline argument.
684 \param ftdi pointer to ftdi_context
685 \param description NULL-terminated description-string, using this format:
686 \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
687 \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")
688 \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
689 \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
691 \note The description format may be extended in later versions.
694 \retval -1: libusb_init() failed
695 \retval -2: libusb_get_device_list() failed
696 \retval -3: usb device not found
697 \retval -4: unable to open device
698 \retval -5: unable to claim device
699 \retval -6: reset failed
700 \retval -7: set baudrate failed
701 \retval -8: get product description failed
702 \retval -9: get serial number failed
703 \retval -10: unable to close device
704 \retval -11: illegal description format
705 \retval -12: ftdi context invalid
707 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
710 ftdi_error_return(-12, "ftdi context invalid");
712 if (description[0] == 0 || description[1] != ':')
713 ftdi_error_return(-11, "illegal description format");
715 if (description[0] == 'd')
718 libusb_device **devs;
719 unsigned int bus_number, device_address;
722 if (libusb_init (NULL) < 0)
723 ftdi_error_return(-1, "libusb_init() failed");
725 if (libusb_get_device_list(NULL, &devs) < 0)
726 ftdi_error_return(-2, "libusb_get_device_list() failed");
728 /* XXX: This doesn't handle symlinks/odd paths/etc... */
729 if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
730 ftdi_error_return(-11, "illegal description format");
732 while ((dev = devs[i++]) != NULL)
734 if (bus_number == libusb_get_bus_number (dev)
735 && device_address == libusb_get_device_address (dev))
736 return ftdi_usb_open_dev(ftdi, dev);
740 ftdi_error_return(-3, "device not found");
742 else if (description[0] == 'i' || description[0] == 's')
745 unsigned int product;
746 unsigned int index=0;
747 const char *serial=NULL;
748 const char *startp, *endp;
751 startp=description+2;
752 vendor=strtoul((char*)startp,(char**)&endp,0);
753 if (*endp != ':' || endp == startp || errno != 0)
754 ftdi_error_return(-11, "illegal description format");
757 product=strtoul((char*)startp,(char**)&endp,0);
758 if (endp == startp || errno != 0)
759 ftdi_error_return(-11, "illegal description format");
761 if (description[0] == 'i' && *endp != 0)
763 /* optional index field in i-mode */
765 ftdi_error_return(-11, "illegal description format");
768 index=strtoul((char*)startp,(char**)&endp,0);
769 if (*endp != 0 || endp == startp || errno != 0)
770 ftdi_error_return(-11, "illegal description format");
772 if (description[0] == 's')
775 ftdi_error_return(-11, "illegal description format");
777 /* rest of the description is the serial */
781 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
785 ftdi_error_return(-11, "illegal description format");
790 Resets the ftdi device.
792 \param ftdi pointer to ftdi_context
795 \retval -1: FTDI reset failed
796 \retval -2: USB device unavailable
798 int ftdi_usb_reset(struct ftdi_context *ftdi)
800 if (ftdi == NULL || ftdi->usb_dev == NULL)
801 ftdi_error_return(-2, "USB device unavailable");
803 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
804 SIO_RESET_REQUEST, SIO_RESET_SIO,
805 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
806 ftdi_error_return(-1,"FTDI reset failed");
808 // Invalidate data in the readbuffer
809 ftdi->readbuffer_offset = 0;
810 ftdi->readbuffer_remaining = 0;
816 Clears the read buffer on the chip and the internal read buffer.
818 \param ftdi pointer to ftdi_context
821 \retval -1: read buffer purge failed
822 \retval -2: USB device unavailable
824 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
826 if (ftdi == NULL || ftdi->usb_dev == NULL)
827 ftdi_error_return(-2, "USB device unavailable");
829 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
830 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
831 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
832 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
834 // Invalidate data in the readbuffer
835 ftdi->readbuffer_offset = 0;
836 ftdi->readbuffer_remaining = 0;
842 Clears the write buffer on the chip.
844 \param ftdi pointer to ftdi_context
847 \retval -1: write buffer purge failed
848 \retval -2: USB device unavailable
850 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
852 if (ftdi == NULL || ftdi->usb_dev == NULL)
853 ftdi_error_return(-2, "USB device unavailable");
855 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
856 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
857 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
858 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
864 Clears the buffers on the chip and the internal read buffer.
866 \param ftdi pointer to ftdi_context
869 \retval -1: read buffer purge failed
870 \retval -2: write buffer purge failed
871 \retval -3: USB device unavailable
873 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
877 if (ftdi == NULL || ftdi->usb_dev == NULL)
878 ftdi_error_return(-3, "USB device unavailable");
880 result = ftdi_usb_purge_rx_buffer(ftdi);
884 result = ftdi_usb_purge_tx_buffer(ftdi);
894 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
896 \param ftdi pointer to ftdi_context
899 \retval -1: usb_release failed
900 \retval -3: ftdi context invalid
902 int ftdi_usb_close(struct ftdi_context *ftdi)
907 ftdi_error_return(-3, "ftdi context invalid");
909 if (ftdi->usb_dev != NULL)
910 if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
913 ftdi_usb_close_internal (ftdi);
919 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
920 Function is only used internally
923 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
924 unsigned short *value, unsigned short *index)
926 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
927 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
928 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
929 int divisor, best_divisor, best_baud, best_baud_diff;
930 unsigned long encoded_divisor;
939 divisor = 24000000 / baudrate;
941 if (ftdi->type == TYPE_AM)
943 // Round down to supported fraction (AM only)
944 divisor -= am_adjust_dn[divisor & 7];
947 // Try this divisor and the one above it (because division rounds down)
951 for (i = 0; i < 2; i++)
953 int try_divisor = divisor + i;
957 // Round up to supported divisor value
958 if (try_divisor <= 8)
960 // Round up to minimum supported divisor
963 else if (ftdi->type != TYPE_AM && try_divisor < 12)
965 // BM doesn't support divisors 9 through 11 inclusive
968 else if (divisor < 16)
970 // AM doesn't support divisors 9 through 15 inclusive
975 if (ftdi->type == TYPE_AM)
977 // Round up to supported fraction (AM only)
978 try_divisor += am_adjust_up[try_divisor & 7];
979 if (try_divisor > 0x1FFF8)
981 // Round down to maximum supported divisor value (for AM)
982 try_divisor = 0x1FFF8;
987 if (try_divisor > 0x1FFFF)
989 // Round down to maximum supported divisor value (for BM)
990 try_divisor = 0x1FFFF;
994 // Get estimated baud rate (to nearest integer)
995 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
996 // Get absolute difference from requested baud rate
997 if (baud_estimate < baudrate)
999 baud_diff = baudrate - baud_estimate;
1003 baud_diff = baud_estimate - baudrate;
1005 if (i == 0 || baud_diff < best_baud_diff)
1007 // Closest to requested baud rate so far
1008 best_divisor = try_divisor;
1009 best_baud = baud_estimate;
1010 best_baud_diff = baud_diff;
1013 // Spot on! No point trying
1018 // Encode the best divisor value
1019 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1020 // Deal with special cases for encoded value
1021 if (encoded_divisor == 1)
1023 encoded_divisor = 0; // 3000000 baud
1025 else if (encoded_divisor == 0x4001)
1027 encoded_divisor = 1; // 2000000 baud (BM only)
1029 // Split into "value" and "index" values
1030 *value = (unsigned short)(encoded_divisor & 0xFFFF);
1031 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
1033 *index = (unsigned short)(encoded_divisor >> 8);
1035 *index |= ftdi->index;
1038 *index = (unsigned short)(encoded_divisor >> 16);
1040 // Return the nearest baud rate
1045 Sets the chip baud rate
1047 \param ftdi pointer to ftdi_context
1048 \param baudrate baud rate to set
1051 \retval -1: invalid baudrate
1052 \retval -2: setting baudrate failed
1053 \retval -3: USB device unavailable
1055 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1057 unsigned short value, index;
1058 int actual_baudrate;
1060 if (ftdi == NULL || ftdi->usb_dev == NULL)
1061 ftdi_error_return(-3, "USB device unavailable");
1063 if (ftdi->bitbang_enabled)
1065 baudrate = baudrate*4;
1068 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1069 if (actual_baudrate <= 0)
1070 ftdi_error_return (-1, "Silly baudrate <= 0.");
1072 // Check within tolerance (about 5%)
1073 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1074 || ((actual_baudrate < baudrate)
1075 ? (actual_baudrate * 21 < baudrate * 20)
1076 : (baudrate * 21 < actual_baudrate * 20)))
1077 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1079 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1080 SIO_SET_BAUDRATE_REQUEST, value,
1081 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1082 ftdi_error_return (-2, "Setting new baudrate failed");
1084 ftdi->baudrate = baudrate;
1089 Set (RS232) line characteristics.
1090 The break type can only be set via ftdi_set_line_property2()
1091 and defaults to "off".
1093 \param ftdi pointer to ftdi_context
1094 \param bits Number of bits
1095 \param sbit Number of stop bits
1096 \param parity Parity mode
1099 \retval -1: Setting line property failed
1101 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1102 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1104 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1108 Set (RS232) line characteristics
1110 \param ftdi pointer to ftdi_context
1111 \param bits Number of bits
1112 \param sbit Number of stop bits
1113 \param parity Parity mode
1114 \param break_type Break type
1117 \retval -1: Setting line property failed
1118 \retval -2: USB device unavailable
1120 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1121 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1122 enum ftdi_break_type break_type)
1124 unsigned short value = bits;
1126 if (ftdi == NULL || ftdi->usb_dev == NULL)
1127 ftdi_error_return(-2, "USB device unavailable");
1132 value |= (0x00 << 8);
1135 value |= (0x01 << 8);
1138 value |= (0x02 << 8);
1141 value |= (0x03 << 8);
1144 value |= (0x04 << 8);
1151 value |= (0x00 << 11);
1154 value |= (0x01 << 11);
1157 value |= (0x02 << 11);
1164 value |= (0x00 << 14);
1167 value |= (0x01 << 14);
1171 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1172 SIO_SET_DATA_REQUEST, value,
1173 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1174 ftdi_error_return (-1, "Setting new line property failed");
1180 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1182 \param ftdi pointer to ftdi_context
1183 \param buf Buffer with the data
1184 \param size Size of the buffer
1186 \retval -666: USB device unavailable
1187 \retval <0: error code from usb_bulk_write()
1188 \retval >0: number of bytes written
1190 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1195 if (ftdi == NULL || ftdi->usb_dev == NULL)
1196 ftdi_error_return(-666, "USB device unavailable");
1198 while (offset < size)
1200 int write_size = ftdi->writebuffer_chunksize;
1202 if (offset+write_size > size)
1203 write_size = size-offset;
1205 if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1206 ftdi_error_return(-1, "usb bulk write failed");
1208 offset += actual_length;
1214 #ifdef LIBFTDI_LINUX_ASYNC_MODE
1215 #ifdef USB_CLASS_PTP
1216 #error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
1218 static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1220 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1221 struct ftdi_context *ftdi = tc->ftdi;
1222 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1224 packet_size = ftdi->max_packet_size;
1226 actual_length = transfer->actual_length;
1228 if (actual_length > 2)
1230 // skip FTDI status bytes.
1231 // Maybe stored in the future to enable modem use
1232 num_of_chunks = actual_length / packet_size;
1233 chunk_remains = actual_length % packet_size;
1234 //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);
1236 ftdi->readbuffer_offset += 2;
1239 if (actual_length > packet_size - 2)
1241 for (i = 1; i < num_of_chunks; i++)
1242 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1243 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1245 if (chunk_remains > 2)
1247 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1248 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1250 actual_length -= 2*num_of_chunks;
1253 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1256 if (actual_length > 0)
1258 // data still fits in buf?
1259 if (tc->offset + actual_length <= tc->size)
1261 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1262 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1263 tc->offset += actual_length;
1265 ftdi->readbuffer_offset = 0;
1266 ftdi->readbuffer_remaining = 0;
1268 /* Did we read exactly the right amount of bytes? */
1269 if (tc->offset == tc->size)
1271 //printf("read_data exact rem %d offset %d\n",
1272 //ftdi->readbuffer_remaining, offset);
1279 // only copy part of the data or size <= readbuffer_chunksize
1280 int part_size = tc->size - tc->offset;
1281 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1282 tc->offset += part_size;
1284 ftdi->readbuffer_offset += part_size;
1285 ftdi->readbuffer_remaining = actual_length - part_size;
1287 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1288 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1294 ret = libusb_submit_transfer (transfer);
1300 static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1302 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1303 struct ftdi_context *ftdi = tc->ftdi;
1305 tc->offset = transfer->actual_length;
1307 if (tc->offset == tc->size)
1313 int write_size = ftdi->writebuffer_chunksize;
1316 if (tc->offset + write_size > tc->size)
1317 write_size = tc->size - tc->offset;
1319 transfer->length = write_size;
1320 transfer->buffer = tc->buf + tc->offset;
1321 ret = libusb_submit_transfer (transfer);
1329 Writes data to the chip. Does not wait for completion of the transfer
1330 nor does it make sure that the transfer was successful.
1332 Use libusb 1.0 Asynchronous API.
1333 Only available if compiled with --with-async-mode.
1335 \param ftdi pointer to ftdi_context
1336 \param buf Buffer with the data
1337 \param size Size of the buffer
1339 \retval NULL: Some error happens when submit transfer
1340 \retval !NULL: Pointer to a ftdi_transfer_control
1343 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1345 struct ftdi_transfer_control *tc;
1346 struct libusb_transfer *transfer = libusb_alloc_transfer(0);
1347 int write_size, ret;
1349 if (ftdi == NULL || ftdi->usb_dev == NULL)
1351 libusb_free_transfer(transfer);
1355 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1357 if (!tc || !transfer)
1366 if (size < ftdi->writebuffer_chunksize)
1369 write_size = ftdi->writebuffer_chunksize;
1371 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf, write_size, ftdi_write_data_cb, tc, ftdi->usb_write_timeout);
1372 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1374 ret = libusb_submit_transfer(transfer);
1377 libusb_free_transfer(transfer);
1379 tc->transfer = NULL;
1382 tc->transfer = transfer;
1388 Reads data from the chip. Does not wait for completion of the transfer
1389 nor does it make sure that the transfer was successful.
1391 Use libusb 1.0 Asynchronous API.
1392 Only available if compiled with --with-async-mode.
1394 \param ftdi pointer to ftdi_context
1395 \param buf Buffer with the data
1396 \param size Size of the buffer
1398 \retval NULL: Some error happens when submit transfer
1399 \retval !NULL: Pointer to a ftdi_transfer_control
1402 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1404 struct ftdi_transfer_control *tc;
1405 struct libusb_transfer *transfer;
1408 if (ftdi == NULL || ftdi->usb_dev == NULL)
1411 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1419 if (size <= ftdi->readbuffer_remaining)
1421 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1424 ftdi->readbuffer_remaining -= size;
1425 ftdi->readbuffer_offset += size;
1427 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1431 tc->transfer = NULL;
1436 if (ftdi->readbuffer_remaining != 0)
1438 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1440 tc->offset = ftdi->readbuffer_remaining;
1445 transfer = libusb_alloc_transfer(0);
1452 ftdi->readbuffer_remaining = 0;
1453 ftdi->readbuffer_offset = 0;
1455 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);
1456 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1458 ret = libusb_submit_transfer(transfer);
1461 libusb_free_transfer(transfer);
1465 tc->transfer = transfer;
1471 Wait for completion of the transfer.
1473 Use libusb 1.0 Asynchronous API.
1474 Only available if compiled with --with-async-mode.
1476 \param tc pointer to ftdi_transfer_control
1478 \retval < 0: Some error happens
1479 \retval >= 0: Data size transferred
1482 int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1486 while (!tc->completed)
1488 ret = libusb_handle_events(NULL);
1491 if (ret == LIBUSB_ERROR_INTERRUPTED)
1493 libusb_cancel_transfer(tc->transfer);
1494 while (!tc->completed)
1495 if (libusb_handle_events(NULL) < 0)
1497 libusb_free_transfer(tc->transfer);
1504 if (tc->transfer->status == LIBUSB_TRANSFER_COMPLETED)
1509 libusb_free_transfer(tc->transfer);
1514 #endif // LIBFTDI_LINUX_ASYNC_MODE
1517 Configure write buffer chunk size.
1520 \param ftdi pointer to ftdi_context
1521 \param chunksize Chunk size
1524 \retval -1: ftdi context invalid
1526 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1529 ftdi_error_return(-1, "ftdi context invalid");
1531 ftdi->writebuffer_chunksize = chunksize;
1536 Get write buffer chunk size.
1538 \param ftdi pointer to ftdi_context
1539 \param chunksize Pointer to store chunk size in
1542 \retval -1: ftdi context invalid
1544 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1547 ftdi_error_return(-1, "ftdi context invalid");
1549 *chunksize = ftdi->writebuffer_chunksize;
1554 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1556 Automatically strips the two modem status bytes transfered during every read.
1558 \param ftdi pointer to ftdi_context
1559 \param buf Buffer to store data in
1560 \param size Size of the buffer
1562 \retval -666: USB device unavailable
1563 \retval <0: error code from libusb_bulk_transfer()
1564 \retval 0: no data was available
1565 \retval >0: number of bytes read
1568 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1570 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1571 int packet_size = ftdi->max_packet_size;
1572 int actual_length = 1;
1574 if (ftdi == NULL || ftdi->usb_dev == NULL)
1575 ftdi_error_return(-666, "USB device unavailable");
1577 // Packet size sanity check (avoid division by zero)
1578 if (packet_size == 0)
1579 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1581 // everything we want is still in the readbuffer?
1582 if (size <= ftdi->readbuffer_remaining)
1584 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1587 ftdi->readbuffer_remaining -= size;
1588 ftdi->readbuffer_offset += size;
1590 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1594 // something still in the readbuffer, but not enough to satisfy 'size'?
1595 if (ftdi->readbuffer_remaining != 0)
1597 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1600 offset += ftdi->readbuffer_remaining;
1602 // do the actual USB read
1603 while (offset < size && actual_length > 0)
1605 ftdi->readbuffer_remaining = 0;
1606 ftdi->readbuffer_offset = 0;
1607 /* returns how much received */
1608 ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1610 ftdi_error_return(ret, "usb bulk read failed");
1612 if (actual_length > 2)
1614 // skip FTDI status bytes.
1615 // Maybe stored in the future to enable modem use
1616 num_of_chunks = actual_length / packet_size;
1617 chunk_remains = actual_length % packet_size;
1618 //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);
1620 ftdi->readbuffer_offset += 2;
1623 if (actual_length > packet_size - 2)
1625 for (i = 1; i < num_of_chunks; i++)
1626 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1627 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1629 if (chunk_remains > 2)
1631 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1632 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1634 actual_length -= 2*num_of_chunks;
1637 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1640 else if (actual_length <= 2)
1642 // no more data to read?
1645 if (actual_length > 0)
1647 // data still fits in buf?
1648 if (offset+actual_length <= size)
1650 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1651 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1652 offset += actual_length;
1654 /* Did we read exactly the right amount of bytes? */
1656 //printf("read_data exact rem %d offset %d\n",
1657 //ftdi->readbuffer_remaining, offset);
1662 // only copy part of the data or size <= readbuffer_chunksize
1663 int part_size = size-offset;
1664 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1666 ftdi->readbuffer_offset += part_size;
1667 ftdi->readbuffer_remaining = actual_length-part_size;
1668 offset += part_size;
1670 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1671 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1682 Configure read buffer chunk size.
1685 Automatically reallocates the buffer.
1687 \param ftdi pointer to ftdi_context
1688 \param chunksize Chunk size
1691 \retval -1: ftdi context invalid
1693 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1695 unsigned char *new_buf;
1698 ftdi_error_return(-1, "ftdi context invalid");
1700 // Invalidate all remaining data
1701 ftdi->readbuffer_offset = 0;
1702 ftdi->readbuffer_remaining = 0;
1704 /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1705 which is defined in libusb-1.0. Otherwise, each USB read request will
1706 be divided into multiple URBs. This will cause issues on Linux kernel
1707 older than 2.6.32. */
1708 if (chunksize > 16384)
1712 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1713 ftdi_error_return(-1, "out of memory for readbuffer");
1715 ftdi->readbuffer = new_buf;
1716 ftdi->readbuffer_chunksize = chunksize;
1722 Get read buffer chunk size.
1724 \param ftdi pointer to ftdi_context
1725 \param chunksize Pointer to store chunk size in
1728 \retval -1: FTDI context invalid
1730 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1733 ftdi_error_return(-1, "FTDI context invalid");
1735 *chunksize = ftdi->readbuffer_chunksize;
1741 Enable bitbang mode.
1743 \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
1745 \param ftdi pointer to ftdi_context
1746 \param bitmask Bitmask to configure lines.
1747 HIGH/ON value configures a line as output.
1750 \retval -1: can't enable bitbang mode
1751 \retval -2: USB device unavailable
1753 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1755 unsigned short usb_val;
1757 if (ftdi == NULL || ftdi->usb_dev == NULL)
1758 ftdi_error_return(-2, "USB device unavailable");
1760 usb_val = bitmask; // low byte: bitmask
1761 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1762 usb_val |= (ftdi->bitbang_mode << 8);
1764 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1765 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1766 NULL, 0, ftdi->usb_write_timeout) < 0)
1767 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1769 ftdi->bitbang_enabled = 1;
1774 Disable bitbang mode.
1776 \param ftdi pointer to ftdi_context
1779 \retval -1: can't disable bitbang mode
1780 \retval -2: USB device unavailable
1782 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1784 if (ftdi == NULL || ftdi->usb_dev == NULL)
1785 ftdi_error_return(-2, "USB device unavailable");
1787 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)
1788 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1790 ftdi->bitbang_enabled = 0;
1795 Enable/disable bitbang modes.
1797 \param ftdi pointer to ftdi_context
1798 \param bitmask Bitmask to configure lines.
1799 HIGH/ON value configures a line as output.
1800 \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1803 \retval -1: can't enable bitbang mode
1804 \retval -2: USB device unavailable
1806 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1808 unsigned short usb_val;
1810 if (ftdi == NULL || ftdi->usb_dev == NULL)
1811 ftdi_error_return(-2, "USB device unavailable");
1813 usb_val = bitmask; // low byte: bitmask
1814 usb_val |= (mode << 8);
1815 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)
1816 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1818 ftdi->bitbang_mode = mode;
1819 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1824 Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1826 \param ftdi pointer to ftdi_context
1827 \param pins Pointer to store pins into
1830 \retval -1: read pins failed
1831 \retval -2: USB device unavailable
1833 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1835 if (ftdi == NULL || ftdi->usb_dev == NULL)
1836 ftdi_error_return(-2, "USB device unavailable");
1838 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)
1839 ftdi_error_return(-1, "read pins failed");
1847 The FTDI chip keeps data in the internal buffer for a specific
1848 amount of time if the buffer is not full yet to decrease
1849 load on the usb bus.
1851 \param ftdi pointer to ftdi_context
1852 \param latency Value between 1 and 255
1855 \retval -1: latency out of range
1856 \retval -2: unable to set latency timer
1857 \retval -3: USB device unavailable
1859 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1861 unsigned short usb_val;
1864 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1866 if (ftdi == NULL || ftdi->usb_dev == NULL)
1867 ftdi_error_return(-3, "USB device unavailable");
1870 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)
1871 ftdi_error_return(-2, "unable to set latency timer");
1879 \param ftdi pointer to ftdi_context
1880 \param latency Pointer to store latency value in
1883 \retval -1: unable to get latency timer
1884 \retval -2: USB device unavailable
1886 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1888 unsigned short usb_val;
1890 if (ftdi == NULL || ftdi->usb_dev == NULL)
1891 ftdi_error_return(-2, "USB device unavailable");
1893 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)
1894 ftdi_error_return(-1, "reading latency timer failed");
1896 *latency = (unsigned char)usb_val;
1901 Poll modem status information
1903 This function allows the retrieve the two status bytes of the device.
1904 The device sends these bytes also as a header for each read access
1905 where they are discarded by ftdi_read_data(). The chip generates
1906 the two stripped status bytes in the absence of data every 40 ms.
1908 Layout of the first byte:
1909 - B0..B3 - must be 0
1910 - B4 Clear to send (CTS)
1913 - B5 Data set ready (DTS)
1916 - B6 Ring indicator (RI)
1919 - B7 Receive line signal detect (RLSD)
1923 Layout of the second byte:
1924 - B0 Data ready (DR)
1925 - B1 Overrun error (OE)
1926 - B2 Parity error (PE)
1927 - B3 Framing error (FE)
1928 - B4 Break interrupt (BI)
1929 - B5 Transmitter holding register (THRE)
1930 - B6 Transmitter empty (TEMT)
1931 - B7 Error in RCVR FIFO
1933 \param ftdi pointer to ftdi_context
1934 \param status Pointer to store status information in. Must be two bytes.
1937 \retval -1: unable to retrieve status information
1938 \retval -2: USB device unavailable
1940 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1944 if (ftdi == NULL || ftdi->usb_dev == NULL)
1945 ftdi_error_return(-2, "USB device unavailable");
1947 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)
1948 ftdi_error_return(-1, "getting modem status failed");
1950 *status = (usb_val[1] << 8) | usb_val[0];
1956 Set flowcontrol for ftdi chip
1958 \param ftdi pointer to ftdi_context
1959 \param flowctrl flow control to use. should be
1960 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1963 \retval -1: set flow control failed
1964 \retval -2: USB device unavailable
1966 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1968 if (ftdi == NULL || ftdi->usb_dev == NULL)
1969 ftdi_error_return(-2, "USB device unavailable");
1971 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1972 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
1973 NULL, 0, ftdi->usb_write_timeout) < 0)
1974 ftdi_error_return(-1, "set flow control failed");
1982 \param ftdi pointer to ftdi_context
1983 \param state state to set line to (1 or 0)
1986 \retval -1: set dtr failed
1987 \retval -2: USB device unavailable
1989 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1991 unsigned short usb_val;
1993 if (ftdi == NULL || ftdi->usb_dev == NULL)
1994 ftdi_error_return(-2, "USB device unavailable");
1997 usb_val = SIO_SET_DTR_HIGH;
1999 usb_val = SIO_SET_DTR_LOW;
2001 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2002 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2003 NULL, 0, ftdi->usb_write_timeout) < 0)
2004 ftdi_error_return(-1, "set dtr failed");
2012 \param ftdi pointer to ftdi_context
2013 \param state state to set line to (1 or 0)
2016 \retval -1: set rts failed
2017 \retval -2: USB device unavailable
2019 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2021 unsigned short usb_val;
2023 if (ftdi == NULL || ftdi->usb_dev == NULL)
2024 ftdi_error_return(-2, "USB device unavailable");
2027 usb_val = SIO_SET_RTS_HIGH;
2029 usb_val = SIO_SET_RTS_LOW;
2031 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2032 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2033 NULL, 0, ftdi->usb_write_timeout) < 0)
2034 ftdi_error_return(-1, "set of rts failed");
2040 Set dtr and rts line in one pass
2042 \param ftdi pointer to ftdi_context
2043 \param dtr DTR state to set line to (1 or 0)
2044 \param rts RTS state to set line to (1 or 0)
2047 \retval -1: set dtr/rts failed
2048 \retval -2: USB device unavailable
2050 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2052 unsigned short usb_val;
2054 if (ftdi == NULL || ftdi->usb_dev == NULL)
2055 ftdi_error_return(-2, "USB device unavailable");
2058 usb_val = SIO_SET_DTR_HIGH;
2060 usb_val = SIO_SET_DTR_LOW;
2063 usb_val |= SIO_SET_RTS_HIGH;
2065 usb_val |= SIO_SET_RTS_LOW;
2067 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2068 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2069 NULL, 0, ftdi->usb_write_timeout) < 0)
2070 ftdi_error_return(-1, "set of rts/dtr failed");
2076 Set the special event character
2078 \param ftdi pointer to ftdi_context
2079 \param eventch Event character
2080 \param enable 0 to disable the event character, non-zero otherwise
2083 \retval -1: unable to set event character
2084 \retval -2: USB device unavailable
2086 int ftdi_set_event_char(struct ftdi_context *ftdi,
2087 unsigned char eventch, unsigned char enable)
2089 unsigned short usb_val;
2091 if (ftdi == NULL || ftdi->usb_dev == NULL)
2092 ftdi_error_return(-2, "USB device unavailable");
2098 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)
2099 ftdi_error_return(-1, "setting event character failed");
2107 \param ftdi pointer to ftdi_context
2108 \param errorch Error character
2109 \param enable 0 to disable the error character, non-zero otherwise
2112 \retval -1: unable to set error character
2113 \retval -2: USB device unavailable
2115 int ftdi_set_error_char(struct ftdi_context *ftdi,
2116 unsigned char errorch, unsigned char enable)
2118 unsigned short usb_val;
2120 if (ftdi == NULL || ftdi->usb_dev == NULL)
2121 ftdi_error_return(-2, "USB device unavailable");
2127 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)
2128 ftdi_error_return(-1, "setting error character failed");
2136 \param ftdi pointer to ftdi_context
2137 \param eeprom Pointer to ftdi_eeprom
2141 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
2146 ftdi->eeprom_size=size;
2151 Init eeprom with default values.
2153 \param eeprom Pointer to ftdi_eeprom
2155 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
2160 eeprom->vendor_id = 0x0403;
2161 eeprom->product_id = 0x6001;
2163 eeprom->self_powered = 1;
2164 eeprom->remote_wakeup = 1;
2165 eeprom->BM_type_chip = 1;
2167 eeprom->in_is_isochronous = 0;
2168 eeprom->out_is_isochronous = 0;
2169 eeprom->suspend_pull_downs = 0;
2171 eeprom->use_serial = 0;
2172 eeprom->change_usb_version = 0;
2173 eeprom->usb_version = 0x0200;
2174 eeprom->max_power = 0;
2176 eeprom->manufacturer = NULL;
2177 eeprom->product = NULL;
2178 eeprom->serial = NULL;
2180 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
2184 Build binary output from ftdi_eeprom structure.
2185 Output is suitable for ftdi_write_eeprom().
2187 \param eeprom Pointer to ftdi_eeprom
2188 \param output Buffer of 128 bytes to store eeprom image to
2190 \retval >0: used eeprom size
2191 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2192 \retval -2: Invalid eeprom pointer
2194 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
2197 unsigned short checksum, value;
2198 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2204 if (eeprom->manufacturer != NULL)
2205 manufacturer_size = strlen(eeprom->manufacturer);
2206 if (eeprom->product != NULL)
2207 product_size = strlen(eeprom->product);
2208 if (eeprom->serial != NULL)
2209 serial_size = strlen(eeprom->serial);
2211 size_check = eeprom->size;
2212 size_check -= 28; // 28 are always in use (fixed)
2214 // Top half of a 256byte eeprom is used just for strings and checksum
2215 // it seems that the FTDI chip will not read these strings from the lower half
2216 // Each string starts with two bytes; offset and type (0x03 for string)
2217 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2218 if (eeprom->size>=256)size_check = 120;
2219 size_check -= manufacturer_size*2;
2220 size_check -= product_size*2;
2221 size_check -= serial_size*2;
2223 // eeprom size exceeded?
2228 memset (output, 0, eeprom->size);
2230 // Addr 00: Stay 00 00
2231 // Addr 02: Vendor ID
2232 output[0x02] = eeprom->vendor_id;
2233 output[0x03] = eeprom->vendor_id >> 8;
2235 // Addr 04: Product ID
2236 output[0x04] = eeprom->product_id;
2237 output[0x05] = eeprom->product_id >> 8;
2239 // Addr 06: Device release number (0400h for BM features)
2240 output[0x06] = 0x00;
2242 if (eeprom->BM_type_chip == 1)
2243 output[0x07] = 0x04;
2245 output[0x07] = 0x02;
2247 // Addr 08: Config descriptor
2249 // Bit 6: 1 if this device is self powered, 0 if bus powered
2250 // Bit 5: 1 if this device uses remote wakeup
2251 // Bit 4: 1 if this device is battery powered
2253 if (eeprom->self_powered == 1)
2255 if (eeprom->remote_wakeup == 1)
2259 // Addr 09: Max power consumption: max power = value * 2 mA
2260 output[0x09] = eeprom->max_power;
2262 // Addr 0A: Chip configuration
2263 // Bit 7: 0 - reserved
2264 // Bit 6: 0 - reserved
2265 // Bit 5: 0 - reserved
2266 // Bit 4: 1 - Change USB version
2267 // Bit 3: 1 - Use the serial number string
2268 // Bit 2: 1 - Enable suspend pull downs for lower power
2269 // Bit 1: 1 - Out EndPoint is Isochronous
2270 // Bit 0: 1 - In EndPoint is Isochronous
2273 if (eeprom->in_is_isochronous == 1)
2275 if (eeprom->out_is_isochronous == 1)
2277 if (eeprom->suspend_pull_downs == 1)
2279 if (eeprom->use_serial == 1)
2281 if (eeprom->change_usb_version == 1)
2285 // Addr 0B: reserved
2286 output[0x0B] = 0x00;
2288 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2289 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2290 if (eeprom->change_usb_version == 1)
2292 output[0x0C] = eeprom->usb_version;
2293 output[0x0D] = eeprom->usb_version >> 8;
2297 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2298 // Addr 0F: Length of manufacturer string
2299 output[0x0F] = manufacturer_size*2 + 2;
2301 // Addr 10: Offset of the product string + 0x80, calculated later
2302 // Addr 11: Length of product string
2303 output[0x11] = product_size*2 + 2;
2305 // Addr 12: Offset of the serial string + 0x80, calculated later
2306 // Addr 13: Length of serial string
2307 output[0x13] = serial_size*2 + 2;
2311 if (eeprom->size>=256) i = 0x80;
2314 // Output manufacturer
2315 output[0x0E] = i | 0x80; // calculate offset
2316 output[i++] = manufacturer_size*2 + 2;
2317 output[i++] = 0x03; // type: string
2318 for (j = 0; j < manufacturer_size; j++)
2320 output[i] = eeprom->manufacturer[j], i++;
2321 output[i] = 0x00, i++;
2324 // Output product name
2325 output[0x10] = i | 0x80; // calculate offset
2326 output[i] = product_size*2 + 2, i++;
2327 output[i] = 0x03, i++;
2328 for (j = 0; j < product_size; j++)
2330 output[i] = eeprom->product[j], i++;
2331 output[i] = 0x00, i++;
2335 output[0x12] = i | 0x80; // calculate offset
2336 output[i] = serial_size*2 + 2, i++;
2337 output[i] = 0x03, i++;
2338 for (j = 0; j < serial_size; j++)
2340 output[i] = eeprom->serial[j], i++;
2341 output[i] = 0x00, i++;
2344 // calculate checksum
2347 for (i = 0; i < eeprom->size/2-1; i++)
2349 value = output[i*2];
2350 value += output[(i*2)+1] << 8;
2352 checksum = value^checksum;
2353 checksum = (checksum << 1) | (checksum >> 15);
2356 output[eeprom->size-2] = checksum;
2357 output[eeprom->size-1] = checksum >> 8;
2363 Decode binary EEPROM image into an ftdi_eeprom structure.
2365 \param eeprom Pointer to ftdi_eeprom which will be filled in.
2366 \param buf Buffer of \a size bytes of raw eeprom data
2367 \param size size size of eeprom data in bytes
2370 \retval -1: something went wrong
2372 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2373 FIXME: Strings are malloc'ed here and should be freed somewhere
2375 int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
2378 unsigned short checksum, eeprom_checksum, value;
2379 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2380 int eeprom_size = 128;
2385 size_check = eeprom->size;
2386 size_check -= 28; // 28 are always in use (fixed)
2388 // Top half of a 256byte eeprom is used just for strings and checksum
2389 // it seems that the FTDI chip will not read these strings from the lower half
2390 // Each string starts with two bytes; offset and type (0x03 for string)
2391 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2392 if (eeprom->size>=256)size_check = 120;
2393 size_check -= manufacturer_size*2;
2394 size_check -= product_size*2;
2395 size_check -= serial_size*2;
2397 // eeprom size exceeded?
2402 // empty eeprom struct
2403 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2405 // Addr 00: Stay 00 00
2407 // Addr 02: Vendor ID
2408 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2410 // Addr 04: Product ID
2411 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2413 value = buf[0x06] + (buf[0x07]<<8);
2417 eeprom->BM_type_chip = 1;
2420 eeprom->BM_type_chip = 0;
2422 default: // Unknown device
2423 eeprom->BM_type_chip = 0;
2427 // Addr 08: Config descriptor
2429 // Bit 6: 1 if this device is self powered, 0 if bus powered
2430 // Bit 5: 1 if this device uses remote wakeup
2431 // Bit 4: 1 if this device is battery powered
2433 if (j&0x40) eeprom->self_powered = 1;
2434 if (j&0x20) eeprom->remote_wakeup = 1;
2436 // Addr 09: Max power consumption: max power = value * 2 mA
2437 eeprom->max_power = buf[0x09];
2439 // Addr 0A: Chip configuration
2440 // Bit 7: 0 - reserved
2441 // Bit 6: 0 - reserved
2442 // Bit 5: 0 - reserved
2443 // Bit 4: 1 - Change USB version
2444 // Bit 3: 1 - Use the serial number string
2445 // Bit 2: 1 - Enable suspend pull downs for lower power
2446 // Bit 1: 1 - Out EndPoint is Isochronous
2447 // Bit 0: 1 - In EndPoint is Isochronous
2450 if (j&0x01) eeprom->in_is_isochronous = 1;
2451 if (j&0x02) eeprom->out_is_isochronous = 1;
2452 if (j&0x04) eeprom->suspend_pull_downs = 1;
2453 if (j&0x08) eeprom->use_serial = 1;
2454 if (j&0x10) eeprom->change_usb_version = 1;
2456 // Addr 0B: reserved
2458 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2459 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2460 if (eeprom->change_usb_version == 1)
2462 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2465 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2466 // Addr 0F: Length of manufacturer string
2467 manufacturer_size = buf[0x0F]/2;
2468 if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
2469 else eeprom->manufacturer = NULL;
2471 // Addr 10: Offset of the product string + 0x80, calculated later
2472 // Addr 11: Length of product string
2473 product_size = buf[0x11]/2;
2474 if (product_size > 0) eeprom->product = malloc(product_size);
2475 else eeprom->product = NULL;
2477 // Addr 12: Offset of the serial string + 0x80, calculated later
2478 // Addr 13: Length of serial string
2479 serial_size = buf[0x13]/2;
2480 if (serial_size > 0) eeprom->serial = malloc(serial_size);
2481 else eeprom->serial = NULL;
2483 // Decode manufacturer
2484 i = buf[0x0E] & 0x7f; // offset
2485 for (j=0;j<manufacturer_size-1;j++)
2487 eeprom->manufacturer[j] = buf[2*j+i+2];
2489 eeprom->manufacturer[j] = '\0';
2491 // Decode product name
2492 i = buf[0x10] & 0x7f; // offset
2493 for (j=0;j<product_size-1;j++)
2495 eeprom->product[j] = buf[2*j+i+2];
2497 eeprom->product[j] = '\0';
2500 i = buf[0x12] & 0x7f; // offset
2501 for (j=0;j<serial_size-1;j++)
2503 eeprom->serial[j] = buf[2*j+i+2];
2505 eeprom->serial[j] = '\0';
2510 for (i = 0; i < eeprom_size/2-1; i++)
2513 value += buf[(i*2)+1] << 8;
2515 checksum = value^checksum;
2516 checksum = (checksum << 1) | (checksum >> 15);
2519 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2521 if (eeprom_checksum != checksum)
2523 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2531 Read eeprom location
2533 \param ftdi pointer to ftdi_context
2534 \param eeprom_addr Address of eeprom location to be read
2535 \param eeprom_val Pointer to store read eeprom location
2538 \retval -1: read failed
2539 \retval -2: USB device unavailable
2541 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2543 if (ftdi == NULL || ftdi->usb_dev == NULL)
2544 ftdi_error_return(-2, "USB device unavailable");
2546 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
2547 ftdi_error_return(-1, "reading eeprom failed");
2555 \param ftdi pointer to ftdi_context
2556 \param eeprom Pointer to store eeprom into
2559 \retval -1: read failed
2560 \retval -2: USB device unavailable
2562 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2566 if (ftdi == NULL || ftdi->usb_dev == NULL)
2567 ftdi_error_return(-2, "USB device unavailable");
2569 for (i = 0; i < ftdi->eeprom_size/2; i++)
2571 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2572 ftdi_error_return(-1, "reading eeprom failed");
2579 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
2580 Function is only used internally
2583 static unsigned char ftdi_read_chipid_shift(unsigned char value)
2585 return ((value & 1) << 1) |
2586 ((value & 2) << 5) |
2587 ((value & 4) >> 2) |
2588 ((value & 8) << 4) |
2589 ((value & 16) >> 1) |
2590 ((value & 32) >> 1) |
2591 ((value & 64) >> 4) |
2592 ((value & 128) >> 2);
2596 Read the FTDIChip-ID from R-type devices
2598 \param ftdi pointer to ftdi_context
2599 \param chipid Pointer to store FTDIChip-ID
2602 \retval -1: read failed
2603 \retval -2: USB device unavailable
2605 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
2607 unsigned int a = 0, b = 0;
2609 if (ftdi == NULL || ftdi->usb_dev == NULL)
2610 ftdi_error_return(-2, "USB device unavailable");
2612 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)
2614 a = a << 8 | a >> 8;
2615 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)
2617 b = b << 8 | b >> 8;
2618 a = (a << 16) | (b & 0xFFFF);
2619 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
2620 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
2621 *chipid = a ^ 0xa5f0f7d1;
2626 ftdi_error_return(-1, "read of FTDIChip-ID failed");
2630 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
2631 Call this function then do a write then call again to see if size changes, if so write again.
2633 \param ftdi pointer to ftdi_context
2634 \param eeprom Pointer to store eeprom into
2635 \param maxsize the size of the buffer to read into
2637 \retval -1: eeprom read failed
2638 \retval -2: USB device unavailable
2639 \retval >=0: size of eeprom
2641 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
2643 int i=0,j,minsize=32;
2646 if (ftdi == NULL || ftdi->usb_dev == NULL)
2647 ftdi_error_return(-2, "USB device unavailable");
2651 for (j = 0; i < maxsize/2 && j<size; j++)
2653 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
2654 SIO_READ_EEPROM_REQUEST, 0, i,
2655 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2656 ftdi_error_return(-1, "eeprom read failed");
2661 while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
2667 Write eeprom location
2669 \param ftdi pointer to ftdi_context
2670 \param eeprom_addr Address of eeprom location to be written
2671 \param eeprom_val Value to be written
2674 \retval -1: read failed
2675 \retval -2: USB device unavailable
2677 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
2679 if (ftdi == NULL || ftdi->usb_dev == NULL)
2680 ftdi_error_return(-2, "USB device unavailable");
2682 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2683 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
2684 NULL, 0, ftdi->usb_write_timeout) != 0)
2685 ftdi_error_return(-1, "unable to write eeprom");
2693 \param ftdi pointer to ftdi_context
2694 \param eeprom Pointer to read eeprom from
2697 \retval -1: read failed
2698 \retval -2: USB device unavailable
2700 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2702 unsigned short usb_val, status;
2705 if (ftdi == NULL || ftdi->usb_dev == NULL)
2706 ftdi_error_return(-2, "USB device unavailable");
2708 /* These commands were traced while running MProg */
2709 if ((ret = ftdi_usb_reset(ftdi)) != 0)
2711 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
2713 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
2716 for (i = 0; i < ftdi->eeprom_size/2; i++)
2718 usb_val = eeprom[i*2];
2719 usb_val += eeprom[(i*2)+1] << 8;
2720 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2721 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
2722 NULL, 0, ftdi->usb_write_timeout) < 0)
2723 ftdi_error_return(-1, "unable to write eeprom");
2732 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
2734 \param ftdi pointer to ftdi_context
2737 \retval -1: erase failed
2738 \retval -2: USB device unavailable
2740 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
2742 if (ftdi == NULL || ftdi->usb_dev == NULL)
2743 ftdi_error_return(-2, "USB device unavailable");
2745 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
2746 ftdi_error_return(-1, "unable to erase eeprom");
2752 Get string representation for last error code
2754 \param ftdi pointer to ftdi_context
2756 \retval Pointer to error string
2758 char *ftdi_get_error_string (struct ftdi_context *ftdi)
2763 return ftdi->error_str;
2766 /* @} end of doxygen libftdi group */