1 /***************************************************************************
5 copyright : (C) 2003-2008 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 */
38 /* stuff needed for async write */
39 #ifdef LIBFTDI_LINUX_ASYNC_MODE
40 #include <sys/ioctl.h>
42 #include <sys/select.h>
43 #include <sys/types.h>
45 #include <linux/usbdevice_fs.h>
48 #define ftdi_error_return(code, str) do { \
49 ftdi->error_str = str; \
54 Internal function to close usb device pointer.
55 Sets ftdi->usb_dev to NULL.
58 \param ftdi pointer to ftdi_context
60 \retval zero if all is fine, otherwise error code from usb_close()
62 static int ftdi_usb_close_internal (struct ftdi_context *ftdi)
68 ret = usb_close (ftdi->usb_dev);
76 Initializes a ftdi_context.
78 \param ftdi pointer to ftdi_context
81 \retval -1: couldn't allocate read buffer
83 \remark This should be called before all functions
85 int ftdi_init(struct ftdi_context *ftdi)
90 ftdi->usb_read_timeout = 5000;
91 ftdi->usb_write_timeout = 5000;
93 ftdi->type = TYPE_BM; /* chip type */
95 ftdi->bitbang_enabled = 0;
97 ftdi->readbuffer = NULL;
98 ftdi->readbuffer_offset = 0;
99 ftdi->readbuffer_remaining = 0;
100 ftdi->writebuffer_chunksize = 4096;
106 ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
108 ftdi->error_str = NULL;
110 #ifdef LIBFTDI_LINUX_ASYNC_MODE
111 ftdi->async_usb_buffer_size=10;
112 if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
113 ftdi_error_return(-1, "out of memory for async usb buffer");
115 /* initialize async usb buffer with unused-marker */
116 for (i=0; i < ftdi->async_usb_buffer_size; i++)
117 ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
119 ftdi->async_usb_buffer_size=0;
120 ftdi->async_usb_buffer = NULL;
123 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
125 /* All fine. Now allocate the readbuffer */
126 return ftdi_read_data_set_chunksize(ftdi, 4096);
130 Allocate and initialize a new ftdi_context
132 \return a pointer to a new ftdi_context, or NULL on failure
134 struct ftdi_context *ftdi_new(void)
136 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
143 if (ftdi_init(ftdi) != 0)
153 Open selected channels on a chip, otherwise use first channel.
155 \param ftdi pointer to ftdi_context
156 \param interface Interface to use for FT2232C/2232H/4232H chips.
159 \retval -1: unknown interface
161 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
167 /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
171 ftdi->index = INTERFACE_B;
177 ftdi->index = INTERFACE_C;
183 ftdi->index = INTERFACE_D;
188 ftdi_error_return(-1, "Unknown interface");
194 Deinitializes a ftdi_context.
196 \param ftdi pointer to ftdi_context
198 void ftdi_deinit(struct ftdi_context *ftdi)
200 ftdi_usb_close_internal (ftdi);
202 if (ftdi->async_usb_buffer != NULL)
204 free(ftdi->async_usb_buffer);
205 ftdi->async_usb_buffer = NULL;
208 if (ftdi->readbuffer != NULL)
210 free(ftdi->readbuffer);
211 ftdi->readbuffer = NULL;
216 Deinitialize and free an ftdi_context.
218 \param ftdi pointer to ftdi_context
220 void ftdi_free(struct ftdi_context *ftdi)
227 Use an already open libusb device.
229 \param ftdi pointer to ftdi_context
230 \param usb libusb usb_dev_handle to use
232 void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
239 Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
240 needs to be deallocated by ftdi_list_free() after use.
242 \param ftdi pointer to ftdi_context
243 \param devlist Pointer where to store list of found devices
244 \param vendor Vendor ID to search for
245 \param product Product ID to search for
247 \retval >0: number of devices found
248 \retval -1: usb_find_busses() failed
249 \retval -2: usb_find_devices() failed
250 \retval -3: out of memory
252 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
254 struct ftdi_device_list **curdev;
256 struct usb_device *dev;
260 if (usb_find_busses() < 0)
261 ftdi_error_return(-1, "usb_find_busses() failed");
262 if (usb_find_devices() < 0)
263 ftdi_error_return(-2, "usb_find_devices() failed");
267 for (bus = usb_get_busses(); bus; bus = bus->next)
269 for (dev = bus->devices; dev; dev = dev->next)
271 if (dev->descriptor.idVendor == vendor
272 && dev->descriptor.idProduct == product)
274 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
276 ftdi_error_return(-3, "out of memory");
278 (*curdev)->next = NULL;
279 (*curdev)->dev = dev;
281 curdev = &(*curdev)->next;
291 Frees a usb device list.
293 \param devlist USB device list created by ftdi_usb_find_all()
295 void ftdi_list_free(struct ftdi_device_list **devlist)
297 struct ftdi_device_list *curdev, *next;
299 for (curdev = *devlist; curdev != NULL;)
310 Frees a usb device list.
312 \param devlist USB device list created by ftdi_usb_find_all()
314 void ftdi_list_free2(struct ftdi_device_list *devlist)
316 ftdi_list_free(&devlist);
320 Return device ID strings from the usb device.
322 The parameters manufacturer, description and serial may be NULL
323 or pointer to buffers to store the fetched strings.
325 \note Use this function only in combination with ftdi_usb_find_all()
326 as it closes the internal "usb_dev" after use.
328 \param ftdi pointer to ftdi_context
329 \param dev libusb usb_dev to use
330 \param manufacturer Store manufacturer string here if not NULL
331 \param mnf_len Buffer size of manufacturer string
332 \param description Store product description string here if not NULL
333 \param desc_len Buffer size of product description string
334 \param serial Store serial string here if not NULL
335 \param serial_len Buffer size of serial string
338 \retval -1: wrong arguments
339 \retval -4: unable to open device
340 \retval -7: get product manufacturer failed
341 \retval -8: get product description failed
342 \retval -9: get serial number failed
343 \retval -10: unable to close device
345 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
346 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
348 if ((ftdi==NULL) || (dev==NULL))
351 if (!(ftdi->usb_dev = usb_open(dev)))
352 ftdi_error_return(-4, usb_strerror());
354 if (manufacturer != NULL)
356 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0)
358 ftdi_usb_close_internal (ftdi);
359 ftdi_error_return(-7, usb_strerror());
363 if (description != NULL)
365 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0)
367 ftdi_usb_close_internal (ftdi);
368 ftdi_error_return(-8, usb_strerror());
374 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0)
376 ftdi_usb_close_internal (ftdi);
377 ftdi_error_return(-9, usb_strerror());
381 if (ftdi_usb_close_internal (ftdi) != 0)
382 ftdi_error_return(-10, usb_strerror());
388 Opens a ftdi device given by a usb_device.
390 \param ftdi pointer to ftdi_context
391 \param dev libusb usb_dev to use
394 \retval -3: unable to config device
395 \retval -4: unable to open device
396 \retval -5: unable to claim device
397 \retval -6: reset failed
398 \retval -7: set baudrate failed
400 int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
402 int detach_errno = 0;
403 if (!(ftdi->usb_dev = usb_open(dev)))
404 ftdi_error_return(-4, "usb_open() failed");
406 #ifdef LIBUSB_HAS_GET_DRIVER_NP
407 // Try to detach ftdi_sio kernel module.
408 // Returns ENODATA if driver is not loaded.
410 // The return code is kept in a separate variable and only parsed
411 // if usb_set_configuration() or usb_claim_interface() fails as the
412 // detach operation might be denied and everything still works fine.
413 // Likely scenario is a static ftdi_sio kernel module.
414 if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
415 detach_errno = errno;
418 // set configuration (needed especially for windows)
419 // tolerate EBUSY: one device with one configuration, but two interfaces
420 // and libftdi sessions to both interfaces (e.g. FT2232)
421 if (dev->descriptor.bNumConfigurations > 0 &&
422 usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue) &&
425 ftdi_usb_close_internal (ftdi);
426 if (detach_errno == EPERM)
428 ftdi_error_return(-8, "inappropriate permissions on device!");
432 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
436 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0)
438 ftdi_usb_close_internal (ftdi);
439 if (detach_errno == EPERM)
441 ftdi_error_return(-8, "inappropriate permissions on device!");
445 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
449 if (ftdi_usb_reset (ftdi) != 0)
451 ftdi_usb_close_internal (ftdi);
452 ftdi_error_return(-6, "ftdi_usb_reset failed");
455 if (ftdi_set_baudrate (ftdi, 9600) != 0)
457 ftdi_usb_close_internal (ftdi);
458 ftdi_error_return(-7, "set baudrate failed");
461 // Try to guess chip type
462 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
463 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
464 && dev->descriptor.iSerialNumber == 0))
465 ftdi->type = TYPE_BM;
466 else if (dev->descriptor.bcdDevice == 0x200)
467 ftdi->type = TYPE_AM;
468 else if (dev->descriptor.bcdDevice == 0x500)
469 ftdi->type = TYPE_2232C;
470 else if (dev->descriptor.bcdDevice == 0x600)
472 else if (dev->descriptor.bcdDevice == 0x700)
473 ftdi->type = TYPE_2232H;
474 else if (dev->descriptor.bcdDevice == 0x800)
475 ftdi->type = TYPE_4232H;
477 // Set default interface on dual/quad type chips
484 ftdi->index = INTERFACE_A;
490 ftdi_error_return(0, "all fine");
494 Opens the first device with a given vendor and product ids.
496 \param ftdi pointer to ftdi_context
497 \param vendor Vendor ID
498 \param product Product ID
500 \retval same as ftdi_usb_open_desc()
502 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
504 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
508 Opens the first device with a given, vendor id, product id,
509 description and serial.
511 \param ftdi pointer to ftdi_context
512 \param vendor Vendor ID
513 \param product Product ID
514 \param description Description to search for. Use NULL if not needed.
515 \param serial Serial to search for. Use NULL if not needed.
518 \retval -1: usb_find_busses() failed
519 \retval -2: usb_find_devices() failed
520 \retval -3: usb device not found
521 \retval -4: unable to open device
522 \retval -5: unable to claim device
523 \retval -6: reset failed
524 \retval -7: set baudrate failed
525 \retval -8: get product description failed
526 \retval -9: get serial number failed
527 \retval -10: unable to close device
529 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
530 const char* description, const char* serial)
533 struct usb_device *dev;
538 if (usb_find_busses() < 0)
539 ftdi_error_return(-1, "usb_find_busses() failed");
540 if (usb_find_devices() < 0)
541 ftdi_error_return(-2, "usb_find_devices() failed");
543 for (bus = usb_get_busses(); bus; bus = bus->next)
545 for (dev = bus->devices; dev; dev = dev->next)
547 if (dev->descriptor.idVendor == vendor
548 && dev->descriptor.idProduct == product)
550 if (!(ftdi->usb_dev = usb_open(dev)))
551 ftdi_error_return(-4, "usb_open() failed");
553 if (description != NULL)
555 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
557 ftdi_usb_close_internal (ftdi);
558 ftdi_error_return(-8, "unable to fetch product description");
560 if (strncmp(string, description, sizeof(string)) != 0)
562 if (ftdi_usb_close_internal (ftdi) != 0)
563 ftdi_error_return(-10, "unable to close device");
569 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
571 ftdi_usb_close_internal (ftdi);
572 ftdi_error_return(-9, "unable to fetch serial number");
574 if (strncmp(string, serial, sizeof(string)) != 0)
576 if (ftdi_usb_close_internal (ftdi) != 0)
577 ftdi_error_return(-10, "unable to close device");
582 if (ftdi_usb_close_internal (ftdi) != 0)
583 ftdi_error_return(-10, "unable to close device");
585 return ftdi_usb_open_dev(ftdi, dev);
591 ftdi_error_return(-3, "device not found");
595 Resets the ftdi device.
597 \param ftdi pointer to ftdi_context
600 \retval -1: FTDI reset failed
602 int ftdi_usb_reset(struct ftdi_context *ftdi)
604 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
605 SIO_RESET_REQUEST, SIO_RESET_SIO,
606 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
607 ftdi_error_return(-1,"FTDI reset failed");
609 // Invalidate data in the readbuffer
610 ftdi->readbuffer_offset = 0;
611 ftdi->readbuffer_remaining = 0;
617 Clears the read buffer on the chip and the internal read buffer.
619 \param ftdi pointer to ftdi_context
622 \retval -1: read buffer purge failed
624 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
626 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
627 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
628 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
629 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
631 // Invalidate data in the readbuffer
632 ftdi->readbuffer_offset = 0;
633 ftdi->readbuffer_remaining = 0;
639 Clears the write buffer on the chip.
641 \param ftdi pointer to ftdi_context
644 \retval -1: write buffer purge failed
646 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
648 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
649 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
650 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
651 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
657 Clears the buffers on the chip and the internal read buffer.
659 \param ftdi pointer to ftdi_context
662 \retval -1: read buffer purge failed
663 \retval -2: write buffer purge failed
665 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
669 result = ftdi_usb_purge_rx_buffer(ftdi);
673 result = ftdi_usb_purge_tx_buffer(ftdi);
683 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
685 \param ftdi pointer to ftdi_context
688 \retval -1: usb_release failed
689 \retval -2: usb_close failed
691 int ftdi_usb_close(struct ftdi_context *ftdi)
695 #ifdef LIBFTDI_LINUX_ASYNC_MODE
696 /* try to release some kernel resources */
697 ftdi_async_complete(ftdi,1);
700 if (ftdi->usb_dev != NULL)
701 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
704 if (ftdi_usb_close_internal (ftdi) != 0)
711 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
712 Function is only used internally
715 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
716 unsigned short *value, unsigned short *index)
718 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
719 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
720 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
721 int divisor, best_divisor, best_baud, best_baud_diff;
722 unsigned long encoded_divisor;
731 divisor = 24000000 / baudrate;
733 if (ftdi->type == TYPE_AM)
735 // Round down to supported fraction (AM only)
736 divisor -= am_adjust_dn[divisor & 7];
739 // Try this divisor and the one above it (because division rounds down)
743 for (i = 0; i < 2; i++)
745 int try_divisor = divisor + i;
749 // Round up to supported divisor value
750 if (try_divisor <= 8)
752 // Round up to minimum supported divisor
755 else if (ftdi->type != TYPE_AM && try_divisor < 12)
757 // BM doesn't support divisors 9 through 11 inclusive
760 else if (divisor < 16)
762 // AM doesn't support divisors 9 through 15 inclusive
767 if (ftdi->type == TYPE_AM)
769 // Round up to supported fraction (AM only)
770 try_divisor += am_adjust_up[try_divisor & 7];
771 if (try_divisor > 0x1FFF8)
773 // Round down to maximum supported divisor value (for AM)
774 try_divisor = 0x1FFF8;
779 if (try_divisor > 0x1FFFF)
781 // Round down to maximum supported divisor value (for BM)
782 try_divisor = 0x1FFFF;
786 // Get estimated baud rate (to nearest integer)
787 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
788 // Get absolute difference from requested baud rate
789 if (baud_estimate < baudrate)
791 baud_diff = baudrate - baud_estimate;
795 baud_diff = baud_estimate - baudrate;
797 if (i == 0 || baud_diff < best_baud_diff)
799 // Closest to requested baud rate so far
800 best_divisor = try_divisor;
801 best_baud = baud_estimate;
802 best_baud_diff = baud_diff;
805 // Spot on! No point trying
810 // Encode the best divisor value
811 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
812 // Deal with special cases for encoded value
813 if (encoded_divisor == 1)
815 encoded_divisor = 0; // 3000000 baud
817 else if (encoded_divisor == 0x4001)
819 encoded_divisor = 1; // 2000000 baud (BM only)
821 // Split into "value" and "index" values
822 *value = (unsigned short)(encoded_divisor & 0xFFFF);
823 if (ftdi->type == TYPE_2232C)
825 *index = (unsigned short)(encoded_divisor >> 8);
827 *index |= ftdi->index;
830 *index = (unsigned short)(encoded_divisor >> 16);
832 // Return the nearest baud rate
837 Sets the chip baud rate
839 \param ftdi pointer to ftdi_context
840 \param baudrate baud rate to set
843 \retval -1: invalid baudrate
844 \retval -2: setting baudrate failed
846 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
848 unsigned short value, index;
851 if (ftdi->bitbang_enabled)
853 baudrate = baudrate*4;
856 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
857 if (actual_baudrate <= 0)
858 ftdi_error_return (-1, "Silly baudrate <= 0.");
860 // Check within tolerance (about 5%)
861 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
862 || ((actual_baudrate < baudrate)
863 ? (actual_baudrate * 21 < baudrate * 20)
864 : (baudrate * 21 < actual_baudrate * 20)))
865 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
867 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
868 SIO_SET_BAUDRATE_REQUEST, value,
869 index, NULL, 0, ftdi->usb_write_timeout) != 0)
870 ftdi_error_return (-2, "Setting new baudrate failed");
872 ftdi->baudrate = baudrate;
877 Set (RS232) line characteristics.
878 The break type can only be set via ftdi_set_line_property2()
879 and defaults to "off".
881 \param ftdi pointer to ftdi_context
882 \param bits Number of bits
883 \param sbit Number of stop bits
884 \param parity Parity mode
887 \retval -1: Setting line property failed
889 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
890 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
892 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
896 Set (RS232) line characteristics
898 \param ftdi pointer to ftdi_context
899 \param bits Number of bits
900 \param sbit Number of stop bits
901 \param parity Parity mode
902 \param break_type Break type
905 \retval -1: Setting line property failed
907 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
908 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
909 enum ftdi_break_type break_type)
911 unsigned short value = bits;
916 value |= (0x00 << 8);
919 value |= (0x01 << 8);
922 value |= (0x02 << 8);
925 value |= (0x03 << 8);
928 value |= (0x04 << 8);
935 value |= (0x00 << 11);
938 value |= (0x01 << 11);
941 value |= (0x02 << 11);
948 value |= (0x00 << 14);
951 value |= (0x01 << 14);
955 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
956 SIO_SET_DATA_REQUEST, value,
957 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
958 ftdi_error_return (-1, "Setting new line property failed");
964 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
966 \param ftdi pointer to ftdi_context
967 \param buf Buffer with the data
968 \param size Size of the buffer
970 \retval <0: error code from usb_bulk_write()
971 \retval >0: number of bytes written
973 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
977 int total_written = 0;
979 while (offset < size)
981 int write_size = ftdi->writebuffer_chunksize;
983 if (offset+write_size > size)
984 write_size = size-offset;
986 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
988 ftdi_error_return(ret, "usb bulk write failed");
990 total_written += ret;
991 offset += write_size;
994 return total_written;
997 #ifdef LIBFTDI_LINUX_ASYNC_MODE
999 #error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
1001 /* this is strongly dependent on libusb using the same struct layout. If libusb
1002 changes in some later version this may break horribly (this is for libusb 0.1.12) */
1003 struct usb_dev_handle
1006 // some other stuff coming here we don't need
1010 Check for pending async urbs
1013 static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
1015 struct usbdevfs_urb *urb;
1019 for (i=0; i < ftdi->async_usb_buffer_size; i++)
1021 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1022 if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
1030 Wait until one or more async URBs are completed by the kernel and mark their
1031 positions in the async-buffer as unused
1033 \param ftdi pointer to ftdi_context
1034 \param wait_for_more if != 0 wait for more than one write to complete
1035 \param timeout_msec max milliseconds to wait
1039 static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
1042 struct usbdevfs_urb *urb=NULL;
1048 FD_SET(ftdi->usb_dev->fd, &writefds);
1050 /* init timeout only once, select writes time left after call */
1051 tv.tv_sec = timeout_msec / 1000;
1052 tv.tv_usec = (timeout_msec % 1000) * 1000;
1056 while (_usb_get_async_urbs_pending(ftdi)
1057 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
1060 if (keep_going && !wait_for_more)
1062 /* don't wait if repeating only for keep_going */
1067 /* wait for timeout msec or something written ready */
1068 select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
1071 if (ret == 0 && urb != NULL)
1073 /* got a free urb, mark it */
1074 urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
1076 /* try to get more urbs that are ready now, but don't wait anymore */
1082 /* no more urbs waiting */
1090 Wait until one or more async URBs are completed by the kernel and mark their
1091 positions in the async-buffer as unused.
1093 \param ftdi pointer to ftdi_context
1094 \param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
1096 void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
1098 _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
1102 Stupid libusb does not offer async writes nor does it allow
1103 access to its fd - so we need some hacks here.
1106 static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
1108 struct usbdevfs_urb *urb;
1109 int bytesdone = 0, requested;
1110 int ret, cleanup_count;
1115 /* find a free urb buffer we can use */
1117 for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
1119 if (i==ftdi->async_usb_buffer_size)
1121 /* wait until some buffers are free */
1122 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
1125 for (i=0; i < ftdi->async_usb_buffer_size; i++)
1127 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1128 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
1129 break; /* found a free urb position */
1134 /* no free urb position found */
1138 requested = size - bytesdone;
1139 if (requested > 4096)
1142 memset(urb,0,sizeof(urb));
1144 urb->type = USBDEVFS_URB_TYPE_BULK;
1147 urb->buffer = bytes + bytesdone;
1148 urb->buffer_length = requested;
1150 urb->actual_length = 0;
1151 urb->number_of_packets = 0;
1152 urb->usercontext = 0;
1156 ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
1158 while (ret < 0 && errno == EINTR);
1160 return ret; /* the caller can read errno to get more info */
1162 bytesdone += requested;
1164 while (bytesdone < size);
1169 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
1170 Does not wait for completion of the transfer nor does it make sure that
1171 the transfer was successful.
1173 This function could be extended to use signals and callbacks to inform the
1174 caller of completion or error - but this is not done yet, volunteers welcome.
1176 Works around libusb and directly accesses functions only available on Linux.
1177 Only available if compiled with --with-async-mode.
1179 \param ftdi pointer to ftdi_context
1180 \param buf Buffer with the data
1181 \param size Size of the buffer
1183 \retval <0: error code from usb_bulk_write()
1184 \retval >0: number of bytes written
1186 int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
1190 int total_written = 0;
1192 while (offset < size)
1194 int write_size = ftdi->writebuffer_chunksize;
1196 if (offset+write_size > size)
1197 write_size = size-offset;
1199 ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
1201 ftdi_error_return(ret, "usb bulk write async failed");
1203 total_written += ret;
1204 offset += write_size;
1207 return total_written;
1209 #endif // LIBFTDI_LINUX_ASYNC_MODE
1212 Configure write buffer chunk size.
1215 \param ftdi pointer to ftdi_context
1216 \param chunksize Chunk size
1220 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1222 ftdi->writebuffer_chunksize = chunksize;
1227 Get write buffer chunk size.
1229 \param ftdi pointer to ftdi_context
1230 \param chunksize Pointer to store chunk size in
1234 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1236 *chunksize = ftdi->writebuffer_chunksize;
1241 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1243 Automatically strips the two modem status bytes transfered during every read.
1245 \param ftdi pointer to ftdi_context
1246 \param buf Buffer to store data in
1247 \param size Size of the buffer
1249 \retval <0: error code from usb_bulk_read()
1250 \retval 0: no data was available
1251 \retval >0: number of bytes read
1253 \remark This function is not useful in bitbang mode.
1254 Use ftdi_read_pins() to get the current state of the pins.
1256 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1258 int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
1261 // New hi-speed devices from FTDI use a packet size of 512 bytes
1262 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
1267 // everything we want is still in the readbuffer?
1268 if (size <= ftdi->readbuffer_remaining)
1270 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1273 ftdi->readbuffer_remaining -= size;
1274 ftdi->readbuffer_offset += size;
1276 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1280 // something still in the readbuffer, but not enough to satisfy 'size'?
1281 if (ftdi->readbuffer_remaining != 0)
1283 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1286 offset += ftdi->readbuffer_remaining;
1288 // do the actual USB read
1289 while (offset < size && ret > 0)
1291 ftdi->readbuffer_remaining = 0;
1292 ftdi->readbuffer_offset = 0;
1293 /* returns how much received */
1294 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
1296 ftdi_error_return(ret, "usb bulk read failed");
1300 // skip FTDI status bytes.
1301 // Maybe stored in the future to enable modem use
1302 num_of_chunks = ret / packet_size;
1303 chunk_remains = ret % packet_size;
1304 //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1306 ftdi->readbuffer_offset += 2;
1309 if (ret > packet_size - 2)
1311 for (i = 1; i < num_of_chunks; i++)
1312 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1313 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1315 if (chunk_remains > 2)
1317 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1318 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1320 ret -= 2*num_of_chunks;
1323 ret -= 2*(num_of_chunks-1)+chunk_remains;
1328 // no more data to read?
1333 // data still fits in buf?
1334 if (offset+ret <= size)
1336 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
1337 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1340 /* Did we read exactly the right amount of bytes? */
1342 //printf("read_data exact rem %d offset %d\n",
1343 //ftdi->readbuffer_remaining, offset);
1348 // only copy part of the data or size <= readbuffer_chunksize
1349 int part_size = size-offset;
1350 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1352 ftdi->readbuffer_offset += part_size;
1353 ftdi->readbuffer_remaining = ret-part_size;
1354 offset += part_size;
1356 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
1357 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
1368 Configure read buffer chunk size.
1371 Automatically reallocates the buffer.
1373 \param ftdi pointer to ftdi_context
1374 \param chunksize Chunk size
1378 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1380 unsigned char *new_buf;
1382 // Invalidate all remaining data
1383 ftdi->readbuffer_offset = 0;
1384 ftdi->readbuffer_remaining = 0;
1386 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1387 ftdi_error_return(-1, "out of memory for readbuffer");
1389 ftdi->readbuffer = new_buf;
1390 ftdi->readbuffer_chunksize = chunksize;
1396 Get read buffer chunk size.
1398 \param ftdi pointer to ftdi_context
1399 \param chunksize Pointer to store chunk size in
1403 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1405 *chunksize = ftdi->readbuffer_chunksize;
1411 Enable bitbang mode.
1413 For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
1415 \param ftdi pointer to ftdi_context
1416 \param bitmask Bitmask to configure lines.
1417 HIGH/ON value configures a line as output.
1420 \retval -1: can't enable bitbang mode
1422 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1424 unsigned short usb_val;
1426 usb_val = bitmask; // low byte: bitmask
1427 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1428 usb_val |= (ftdi->bitbang_mode << 8);
1430 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1431 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1432 NULL, 0, ftdi->usb_write_timeout) != 0)
1433 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1435 ftdi->bitbang_enabled = 1;
1440 Disable bitbang mode.
1442 \param ftdi pointer to ftdi_context
1445 \retval -1: can't disable bitbang mode
1447 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1449 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1450 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1452 ftdi->bitbang_enabled = 0;
1457 Enable advanced bitbang mode for FT2232C chips.
1459 \param ftdi pointer to ftdi_context
1460 \param bitmask Bitmask to configure lines.
1461 HIGH/ON value configures a line as output.
1462 \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
1465 \retval -1: can't enable bitbang mode
1467 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1469 unsigned short usb_val;
1471 usb_val = bitmask; // low byte: bitmask
1472 usb_val |= (mode << 8);
1473 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1474 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1476 ftdi->bitbang_mode = mode;
1477 ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
1482 Directly read pin state. Useful for bitbang mode.
1484 \param ftdi pointer to ftdi_context
1485 \param pins Pointer to store pins into
1488 \retval -1: read pins failed
1490 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1492 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
1493 ftdi_error_return(-1, "read pins failed");
1501 The FTDI chip keeps data in the internal buffer for a specific
1502 amount of time if the buffer is not full yet to decrease
1503 load on the usb bus.
1505 \param ftdi pointer to ftdi_context
1506 \param latency Value between 1 and 255
1509 \retval -1: latency out of range
1510 \retval -2: unable to set latency timer
1512 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1514 unsigned short usb_val;
1517 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1520 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1521 ftdi_error_return(-2, "unable to set latency timer");
1529 \param ftdi pointer to ftdi_context
1530 \param latency Pointer to store latency value in
1533 \retval -1: unable to get latency timer
1535 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1537 unsigned short usb_val;
1538 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1539 ftdi_error_return(-1, "reading latency timer failed");
1541 *latency = (unsigned char)usb_val;
1546 Poll modem status information
1548 This function allows the retrieve the two status bytes of the device.
1549 The device sends these bytes also as a header for each read access
1550 where they are discarded by ftdi_read_data(). The chip generates
1551 the two stripped status bytes in the absence of data every 40 ms.
1553 Layout of the first byte:
1554 - B0..B3 - must be 0
1555 - B4 Clear to send (CTS)
1558 - B5 Data set ready (DTS)
1561 - B6 Ring indicator (RI)
1564 - B7 Receive line signal detect (RLSD)
1568 Layout of the second byte:
1569 - B0 Data ready (DR)
1570 - B1 Overrun error (OE)
1571 - B2 Parity error (PE)
1572 - B3 Framing error (FE)
1573 - B4 Break interrupt (BI)
1574 - B5 Transmitter holding register (THRE)
1575 - B6 Transmitter empty (TEMT)
1576 - B7 Error in RCVR FIFO
1578 \param ftdi pointer to ftdi_context
1579 \param status Pointer to store status information in. Must be two bytes.
1582 \retval -1: unable to retrieve status information
1584 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1588 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
1589 ftdi_error_return(-1, "getting modem status failed");
1591 *status = (usb_val[1] << 8) | usb_val[0];
1597 Set flowcontrol for ftdi chip
1599 \param ftdi pointer to ftdi_context
1600 \param flowctrl flow control to use. should be
1601 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1604 \retval -1: set flow control failed
1606 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1608 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1609 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
1610 NULL, 0, ftdi->usb_write_timeout) != 0)
1611 ftdi_error_return(-1, "set flow control failed");
1619 \param ftdi pointer to ftdi_context
1620 \param state state to set line to (1 or 0)
1623 \retval -1: set dtr failed
1625 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1627 unsigned short usb_val;
1630 usb_val = SIO_SET_DTR_HIGH;
1632 usb_val = SIO_SET_DTR_LOW;
1634 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1635 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1636 NULL, 0, ftdi->usb_write_timeout) != 0)
1637 ftdi_error_return(-1, "set dtr failed");
1645 \param ftdi pointer to ftdi_context
1646 \param state state to set line to (1 or 0)
1649 \retval -1 set rts failed
1651 int ftdi_setrts(struct ftdi_context *ftdi, int state)
1653 unsigned short usb_val;
1656 usb_val = SIO_SET_RTS_HIGH;
1658 usb_val = SIO_SET_RTS_LOW;
1660 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1661 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1662 NULL, 0, ftdi->usb_write_timeout) != 0)
1663 ftdi_error_return(-1, "set of rts failed");
1669 Set dtr and rts line in one pass
1671 \param ftdi pointer to ftdi_context
1672 \param dtr DTR state to set line to (1 or 0)
1673 \param rts RTS state to set line to (1 or 0)
1676 \retval -1 set dtr/rts failed
1678 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
1680 unsigned short usb_val;
1683 usb_val = SIO_SET_DTR_HIGH;
1685 usb_val = SIO_SET_DTR_LOW;
1688 usb_val |= SIO_SET_RTS_HIGH;
1690 usb_val |= SIO_SET_RTS_LOW;
1692 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1693 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1694 NULL, 0, ftdi->usb_write_timeout) != 0)
1695 ftdi_error_return(-1, "set of rts/dtr failed");
1701 Set the special event character
1703 \param ftdi pointer to ftdi_context
1704 \param eventch Event character
1705 \param enable 0 to disable the event character, non-zero otherwise
1708 \retval -1: unable to set event character
1710 int ftdi_set_event_char(struct ftdi_context *ftdi,
1711 unsigned char eventch, unsigned char enable)
1713 unsigned short usb_val;
1719 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1720 ftdi_error_return(-1, "setting event character failed");
1728 \param ftdi pointer to ftdi_context
1729 \param errorch Error character
1730 \param enable 0 to disable the error character, non-zero otherwise
1733 \retval -1: unable to set error character
1735 int ftdi_set_error_char(struct ftdi_context *ftdi,
1736 unsigned char errorch, unsigned char enable)
1738 unsigned short usb_val;
1744 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1745 ftdi_error_return(-1, "setting error character failed");
1753 \param ftdi pointer to ftdi_context
1754 \param eeprom Pointer to ftdi_eeprom
1758 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
1760 ftdi->eeprom_size=size;
1765 Init eeprom with default values.
1767 \param eeprom Pointer to ftdi_eeprom
1769 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
1771 eeprom->vendor_id = 0x0403;
1772 eeprom->product_id = 0x6001;
1774 eeprom->self_powered = 1;
1775 eeprom->remote_wakeup = 1;
1776 eeprom->BM_type_chip = 1;
1778 eeprom->in_is_isochronous = 0;
1779 eeprom->out_is_isochronous = 0;
1780 eeprom->suspend_pull_downs = 0;
1782 eeprom->use_serial = 0;
1783 eeprom->change_usb_version = 0;
1784 eeprom->usb_version = 0x0200;
1785 eeprom->max_power = 0;
1787 eeprom->manufacturer = NULL;
1788 eeprom->product = NULL;
1789 eeprom->serial = NULL;
1791 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
1795 Build binary output from ftdi_eeprom structure.
1796 Output is suitable for ftdi_write_eeprom().
1798 \param eeprom Pointer to ftdi_eeprom
1799 \param output Buffer of 128 bytes to store eeprom image to
1801 \retval >0: used eeprom size
1802 \retval -1: eeprom size (128 bytes) exceeded by custom strings
1804 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
1807 unsigned short checksum, value;
1808 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1811 if (eeprom->manufacturer != NULL)
1812 manufacturer_size = strlen(eeprom->manufacturer);
1813 if (eeprom->product != NULL)
1814 product_size = strlen(eeprom->product);
1815 if (eeprom->serial != NULL)
1816 serial_size = strlen(eeprom->serial);
1818 size_check = eeprom->size;
1819 size_check -= 28; // 28 are always in use (fixed)
1821 // Top half of a 256byte eeprom is used just for strings and checksum
1822 // it seems that the FTDI chip will not read these strings from the lower half
1823 // Each string starts with two bytes; offset and type (0x03 for string)
1824 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1825 if (eeprom->size>=256)size_check = 120;
1826 size_check -= manufacturer_size*2;
1827 size_check -= product_size*2;
1828 size_check -= serial_size*2;
1830 // eeprom size exceeded?
1835 memset (output, 0, eeprom->size);
1837 // Addr 00: Stay 00 00
1838 // Addr 02: Vendor ID
1839 output[0x02] = eeprom->vendor_id;
1840 output[0x03] = eeprom->vendor_id >> 8;
1842 // Addr 04: Product ID
1843 output[0x04] = eeprom->product_id;
1844 output[0x05] = eeprom->product_id >> 8;
1846 // Addr 06: Device release number (0400h for BM features)
1847 output[0x06] = 0x00;
1849 if (eeprom->BM_type_chip == 1)
1850 output[0x07] = 0x04;
1852 output[0x07] = 0x02;
1854 // Addr 08: Config descriptor
1856 // Bit 6: 1 if this device is self powered, 0 if bus powered
1857 // Bit 5: 1 if this device uses remote wakeup
1858 // Bit 4: 1 if this device is battery powered
1860 if (eeprom->self_powered == 1)
1862 if (eeprom->remote_wakeup == 1)
1866 // Addr 09: Max power consumption: max power = value * 2 mA
1867 output[0x09] = eeprom->max_power;
1869 // Addr 0A: Chip configuration
1870 // Bit 7: 0 - reserved
1871 // Bit 6: 0 - reserved
1872 // Bit 5: 0 - reserved
1873 // Bit 4: 1 - Change USB version
1874 // Bit 3: 1 - Use the serial number string
1875 // Bit 2: 1 - Enable suspend pull downs for lower power
1876 // Bit 1: 1 - Out EndPoint is Isochronous
1877 // Bit 0: 1 - In EndPoint is Isochronous
1880 if (eeprom->in_is_isochronous == 1)
1882 if (eeprom->out_is_isochronous == 1)
1884 if (eeprom->suspend_pull_downs == 1)
1886 if (eeprom->use_serial == 1)
1888 if (eeprom->change_usb_version == 1)
1892 // Addr 0B: reserved
1893 output[0x0B] = 0x00;
1895 // Addr 0C: USB version low byte when 0x0A bit 4 is set
1896 // Addr 0D: USB version high byte when 0x0A bit 4 is set
1897 if (eeprom->change_usb_version == 1)
1899 output[0x0C] = eeprom->usb_version;
1900 output[0x0D] = eeprom->usb_version >> 8;
1904 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
1905 // Addr 0F: Length of manufacturer string
1906 output[0x0F] = manufacturer_size*2 + 2;
1908 // Addr 10: Offset of the product string + 0x80, calculated later
1909 // Addr 11: Length of product string
1910 output[0x11] = product_size*2 + 2;
1912 // Addr 12: Offset of the serial string + 0x80, calculated later
1913 // Addr 13: Length of serial string
1914 output[0x13] = serial_size*2 + 2;
1918 if (eeprom->size>=256) i = 0x80;
1921 // Output manufacturer
1922 output[0x0E] = i | 0x80; // calculate offset
1923 output[i++] = manufacturer_size*2 + 2;
1924 output[i++] = 0x03; // type: string
1925 for (j = 0; j < manufacturer_size; j++)
1927 output[i] = eeprom->manufacturer[j], i++;
1928 output[i] = 0x00, i++;
1931 // Output product name
1932 output[0x10] = i | 0x80; // calculate offset
1933 output[i] = product_size*2 + 2, i++;
1934 output[i] = 0x03, i++;
1935 for (j = 0; j < product_size; j++)
1937 output[i] = eeprom->product[j], i++;
1938 output[i] = 0x00, i++;
1942 output[0x12] = i | 0x80; // calculate offset
1943 output[i] = serial_size*2 + 2, i++;
1944 output[i] = 0x03, i++;
1945 for (j = 0; j < serial_size; j++)
1947 output[i] = eeprom->serial[j], i++;
1948 output[i] = 0x00, i++;
1951 // calculate checksum
1954 for (i = 0; i < eeprom->size/2-1; i++)
1956 value = output[i*2];
1957 value += output[(i*2)+1] << 8;
1959 checksum = value^checksum;
1960 checksum = (checksum << 1) | (checksum >> 15);
1963 output[eeprom->size-2] = checksum;
1964 output[eeprom->size-1] = checksum >> 8;
1970 Decode binary EEPROM image into an ftdi_eeprom structure.
1972 \param eeprom Pointer to ftdi_eeprom which will be filled in.
1973 \param buf Buffer of \a size bytes of raw eeprom data
1974 \param size size size of eeprom data in bytes
1977 \retval -1: something went wrong
1979 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
1980 FIXME: Strings are malloc'ed here and should be freed somewhere
1982 int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
1985 unsigned short checksum, eeprom_checksum, value;
1986 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1988 int eeprom_size = 128;
1990 size_check = eeprom->size;
1991 size_check -= 28; // 28 are always in use (fixed)
1993 // Top half of a 256byte eeprom is used just for strings and checksum
1994 // it seems that the FTDI chip will not read these strings from the lower half
1995 // Each string starts with two bytes; offset and type (0x03 for string)
1996 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1997 if (eeprom->size>=256)size_check = 120;
1998 size_check -= manufacturer_size*2;
1999 size_check -= product_size*2;
2000 size_check -= serial_size*2;
2002 // eeprom size exceeded?
2007 // empty eeprom struct
2008 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2010 // Addr 00: Stay 00 00
2012 // Addr 02: Vendor ID
2013 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2015 // Addr 04: Product ID
2016 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2018 value = buf[0x06] + (buf[0x07]<<8);
2022 eeprom->BM_type_chip = 1;
2025 eeprom->BM_type_chip = 0;
2027 default: // Unknown device
2028 eeprom->BM_type_chip = 0;
2032 // Addr 08: Config descriptor
2034 // Bit 6: 1 if this device is self powered, 0 if bus powered
2035 // Bit 5: 1 if this device uses remote wakeup
2036 // Bit 4: 1 if this device is battery powered
2038 if (j&0x40) eeprom->self_powered = 1;
2039 if (j&0x20) eeprom->remote_wakeup = 1;
2041 // Addr 09: Max power consumption: max power = value * 2 mA
2042 eeprom->max_power = buf[0x09];
2044 // Addr 0A: Chip configuration
2045 // Bit 7: 0 - reserved
2046 // Bit 6: 0 - reserved
2047 // Bit 5: 0 - reserved
2048 // Bit 4: 1 - Change USB version
2049 // Bit 3: 1 - Use the serial number string
2050 // Bit 2: 1 - Enable suspend pull downs for lower power
2051 // Bit 1: 1 - Out EndPoint is Isochronous
2052 // Bit 0: 1 - In EndPoint is Isochronous
2055 if (j&0x01) eeprom->in_is_isochronous = 1;
2056 if (j&0x02) eeprom->out_is_isochronous = 1;
2057 if (j&0x04) eeprom->suspend_pull_downs = 1;
2058 if (j&0x08) eeprom->use_serial = 1;
2059 if (j&0x10) eeprom->change_usb_version = 1;
2061 // Addr 0B: reserved
2063 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2064 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2065 if (eeprom->change_usb_version == 1)
2067 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2070 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2071 // Addr 0F: Length of manufacturer string
2072 manufacturer_size = buf[0x0F]/2;
2073 if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
2074 else eeprom->manufacturer = NULL;
2076 // Addr 10: Offset of the product string + 0x80, calculated later
2077 // Addr 11: Length of product string
2078 product_size = buf[0x11]/2;
2079 if (product_size > 0) eeprom->product = malloc(product_size);
2080 else eeprom->product = NULL;
2082 // Addr 12: Offset of the serial string + 0x80, calculated later
2083 // Addr 13: Length of serial string
2084 serial_size = buf[0x13]/2;
2085 if (serial_size > 0) eeprom->serial = malloc(serial_size);
2086 else eeprom->serial = NULL;
2088 // Decode manufacturer
2089 i = buf[0x0E] & 0x7f; // offset
2090 for (j=0;j<manufacturer_size-1;j++)
2092 eeprom->manufacturer[j] = buf[2*j+i+2];
2094 eeprom->manufacturer[j] = '\0';
2096 // Decode product name
2097 i = buf[0x10] & 0x7f; // offset
2098 for (j=0;j<product_size-1;j++)
2100 eeprom->product[j] = buf[2*j+i+2];
2102 eeprom->product[j] = '\0';
2105 i = buf[0x12] & 0x7f; // offset
2106 for (j=0;j<serial_size-1;j++)
2108 eeprom->serial[j] = buf[2*j+i+2];
2110 eeprom->serial[j] = '\0';
2115 for (i = 0; i < eeprom_size/2-1; i++)
2118 value += buf[(i*2)+1] << 8;
2120 checksum = value^checksum;
2121 checksum = (checksum << 1) | (checksum >> 15);
2124 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2126 if (eeprom_checksum != checksum)
2128 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2136 Read eeprom location
2138 \param ftdi pointer to ftdi_context
2139 \param eeprom_addr Address of eeprom location to be read
2140 \param eeprom_val Pointer to store read eeprom location
2143 \retval -1: read failed
2145 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2147 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
2148 ftdi_error_return(-1, "reading eeprom failed");
2156 \param ftdi pointer to ftdi_context
2157 \param eeprom Pointer to store eeprom into
2160 \retval -1: read failed
2162 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2166 for (i = 0; i < ftdi->eeprom_size/2; i++)
2168 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2169 ftdi_error_return(-1, "reading eeprom failed");
2176 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
2177 Function is only used internally
2180 static unsigned char ftdi_read_chipid_shift(unsigned char value)
2182 return ((value & 1) << 1) |
2183 ((value & 2) << 5) |
2184 ((value & 4) >> 2) |
2185 ((value & 8) << 4) |
2186 ((value & 16) >> 1) |
2187 ((value & 32) >> 1) |
2188 ((value & 64) >> 4) |
2189 ((value & 128) >> 2);
2193 Read the FTDIChip-ID from R-type devices
2195 \param ftdi pointer to ftdi_context
2196 \param chipid Pointer to store FTDIChip-ID
2199 \retval -1: read failed
2201 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
2203 unsigned int a = 0, b = 0;
2205 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
2207 a = a << 8 | a >> 8;
2208 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
2210 b = b << 8 | b >> 8;
2211 a = (a << 16) | (b & 0xFFFF);
2212 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
2213 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
2214 *chipid = a ^ 0xa5f0f7d1;
2219 ftdi_error_return(-1, "read of FTDIChip-ID failed");
2223 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
2224 Call this function then do a write then call again to see if size changes, if so write again.
2226 \param ftdi pointer to ftdi_context
2227 \param eeprom Pointer to store eeprom into
2228 \param maxsize the size of the buffer to read into
2230 \retval size of eeprom
2232 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
2234 int i=0,j,minsize=32;
2239 for (j = 0; i < maxsize/2 && j<size; j++)
2241 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
2242 SIO_READ_EEPROM_REQUEST, 0, i,
2243 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2244 ftdi_error_return(-1, "reading eeprom failed");
2249 while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
2255 Write eeprom location
2257 \param ftdi pointer to ftdi_context
2258 \param eeprom_addr Address of eeprom location to be written
2259 \param eeprom_val Value to be written
2262 \retval -1: read failed
2264 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
2266 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2267 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
2268 NULL, 0, ftdi->usb_write_timeout) != 0)
2269 ftdi_error_return(-1, "unable to write eeprom");
2277 \param ftdi pointer to ftdi_context
2278 \param eeprom Pointer to read eeprom from
2281 \retval -1: read failed
2283 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2285 unsigned short usb_val, status;
2288 /* These commands were traced while running MProg */
2289 if ((ret = ftdi_usb_reset(ftdi)) != 0)
2291 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
2293 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
2296 for (i = 0; i < ftdi->eeprom_size/2; i++)
2298 usb_val = eeprom[i*2];
2299 usb_val += eeprom[(i*2)+1] << 8;
2300 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2301 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
2302 NULL, 0, ftdi->usb_write_timeout) != 0)
2303 ftdi_error_return(-1, "unable to write eeprom");
2312 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
2314 \param ftdi pointer to ftdi_context
2317 \retval -1: erase failed
2319 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
2321 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
2322 ftdi_error_return(-1, "unable to erase eeprom");
2328 Get string representation for last error code
2330 \param ftdi pointer to ftdi_context
2332 \retval Pointer to error string
2334 char *ftdi_get_error_string (struct ftdi_context *ftdi)
2336 return ftdi->error_str;
2339 /* @} end of doxygen libftdi group */