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/de/produkte/opensource/ftdi/
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 */
37 /* stuff needed for async write */
38 #ifdef LIBFTDI_LINUX_ASYNC_MODE
39 #include <sys/ioctl.h>
41 #include <sys/select.h>
42 #include <sys/types.h>
44 #include <linux/usbdevice_fs.h>
47 #define ftdi_error_return(code, str) do { \
48 ftdi->error_str = str; \
54 Initializes a ftdi_context.
56 \param ftdi pointer to ftdi_context
59 \retval -1: couldn't allocate read buffer
61 \remark This should be called before all functions
63 int ftdi_init(struct ftdi_context *ftdi)
68 ftdi->usb_read_timeout = 5000;
69 ftdi->usb_write_timeout = 5000;
71 ftdi->type = TYPE_BM; /* chip type */
73 ftdi->bitbang_enabled = 0;
75 ftdi->readbuffer = NULL;
76 ftdi->readbuffer_offset = 0;
77 ftdi->readbuffer_remaining = 0;
78 ftdi->writebuffer_chunksize = 4096;
84 ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
86 ftdi->error_str = NULL;
88 #ifdef LIBFTDI_LINUX_ASYNC_MODE
89 ftdi->async_usb_buffer_size=10;
90 if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
91 ftdi_error_return(-1, "out of memory for async usb buffer");
93 /* initialize async usb buffer with unused-marker */
94 for (i=0; i < ftdi->async_usb_buffer_size; i++)
95 ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
97 ftdi->async_usb_buffer_size=0;
98 ftdi->async_usb_buffer = NULL;
101 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
103 /* All fine. Now allocate the readbuffer */
104 return ftdi_read_data_set_chunksize(ftdi, 4096);
108 Allocate and initialize a new ftdi_context
110 \return a pointer to a new ftdi_context, or NULL on failure
112 struct ftdi_context *ftdi_new()
114 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
120 if (ftdi_init(ftdi) != 0) {
129 Open selected channels on a chip, otherwise use first channel.
131 \param ftdi pointer to ftdi_context
132 \param interface Interface to use for FT2232C chips.
135 \retval -1: unknown interface
137 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
142 /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
146 ftdi->index = INTERFACE_B;
151 ftdi_error_return(-1, "Unknown interface");
157 Deinitializes a ftdi_context.
159 \param ftdi pointer to ftdi_context
161 void ftdi_deinit(struct ftdi_context *ftdi)
163 if (ftdi->async_usb_buffer != NULL) {
164 free(ftdi->async_usb_buffer);
165 ftdi->async_usb_buffer = NULL;
168 if (ftdi->readbuffer != NULL) {
169 free(ftdi->readbuffer);
170 ftdi->readbuffer = NULL;
175 Deinitialize and free an ftdi_context.
177 \param ftdi pointer to ftdi_context
179 void ftdi_free(struct ftdi_context *ftdi)
186 Use an already open libusb device.
188 \param ftdi pointer to ftdi_context
189 \param usb libusb usb_dev_handle to use
191 void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
198 Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
199 needs to be deallocated by ftdi_list_free() after use.
201 \param ftdi pointer to ftdi_context
202 \param devlist Pointer where to store list of found devices
203 \param vendor Vendor ID to search for
204 \param product Product ID to search for
206 \retval >0: number of devices found
207 \retval -1: usb_find_busses() failed
208 \retval -2: usb_find_devices() failed
209 \retval -3: out of memory
211 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
213 struct ftdi_device_list **curdev;
215 struct usb_device *dev;
219 if (usb_find_busses() < 0)
220 ftdi_error_return(-1, "usb_find_busses() failed");
221 if (usb_find_devices() < 0)
222 ftdi_error_return(-2, "usb_find_devices() failed");
226 for (bus = usb_get_busses(); bus; bus = bus->next) {
227 for (dev = bus->devices; dev; dev = dev->next) {
228 if (dev->descriptor.idVendor == vendor
229 && dev->descriptor.idProduct == product)
231 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
233 ftdi_error_return(-3, "out of memory");
235 (*curdev)->next = NULL;
236 (*curdev)->dev = dev;
238 curdev = &(*curdev)->next;
248 Frees a usb device list.
250 \param devlist USB device list created by ftdi_usb_find_all()
252 void ftdi_list_free(struct ftdi_device_list **devlist)
254 struct ftdi_device_list *curdev, *next;
256 for (curdev = *devlist; curdev != NULL;) {
266 Frees a usb device list.
268 \param devlist USB device list created by ftdi_usb_find_all()
270 void ftdi_list_free2(struct ftdi_device_list *devlist)
272 ftdi_list_free(&devlist);
276 Return device ID strings from the usb device.
278 The parameters manufacturer, description and serial may be NULL
279 or pointer to buffers to store the fetched strings.
281 \note Use this function only in combination with ftdi_usb_find_all()
282 as it closes the internal "usb_dev" after use.
284 \param ftdi pointer to ftdi_context
285 \param dev libusb usb_dev to use
286 \param manufacturer Store manufacturer string here if not NULL
287 \param mnf_len Buffer size of manufacturer string
288 \param description Store product description string here if not NULL
289 \param desc_len Buffer size of product description string
290 \param serial Store serial string here if not NULL
291 \param serial_len Buffer size of serial string
294 \retval -1: wrong arguments
295 \retval -4: unable to open device
296 \retval -7: get product manufacturer failed
297 \retval -8: get product description failed
298 \retval -9: get serial number failed
299 \retval -10: unable to close device
301 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
302 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
304 if ((ftdi==NULL) || (dev==NULL))
307 if (!(ftdi->usb_dev = usb_open(dev)))
308 ftdi_error_return(-4, usb_strerror());
310 if (manufacturer != NULL) {
311 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0) {
312 usb_close (ftdi->usb_dev);
313 ftdi_error_return(-7, usb_strerror());
317 if (description != NULL) {
318 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0) {
319 usb_close (ftdi->usb_dev);
320 ftdi_error_return(-8, usb_strerror());
324 if (serial != NULL) {
325 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0) {
326 usb_close (ftdi->usb_dev);
327 ftdi_error_return(-9, usb_strerror());
331 if (usb_close (ftdi->usb_dev) != 0)
332 ftdi_error_return(-10, usb_strerror());
338 Opens a ftdi device given by a usb_device.
340 \param ftdi pointer to ftdi_context
341 \param dev libusb usb_dev to use
344 \retval -3: unable to config device
345 \retval -4: unable to open device
346 \retval -5: unable to claim device
347 \retval -6: reset failed
348 \retval -7: set baudrate failed
350 int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
352 int detach_errno = 0;
353 if (!(ftdi->usb_dev = usb_open(dev)))
354 ftdi_error_return(-4, "usb_open() failed");
356 #ifdef LIBUSB_HAS_GET_DRIVER_NP
357 // Try to detach ftdi_sio kernel module.
358 // Returns ENODATA if driver is not loaded.
360 // The return code is kept in a separate variable and only parsed
361 // if usb_set_configuration() or usb_claim_interface() fails as the
362 // detach operation might be denied and everything still works fine.
363 // Likely scenario is a static ftdi_sio kernel module.
364 if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
365 detach_errno = errno;
368 // set configuration (needed especially for windows)
369 // tolerate EBUSY: one device with one configuration, but two interfaces
370 // and libftdi sessions to both interfaces (e.g. FT2232)
371 if (dev->descriptor.bNumConfigurations > 0 &&
372 usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue) &&
375 usb_close (ftdi->usb_dev);
376 if (detach_errno == EPERM) {
377 ftdi_error_return(-8, "inappropriate permissions on device!");
379 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
383 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
384 usb_close (ftdi->usb_dev);
385 if (detach_errno == EPERM) {
386 ftdi_error_return(-8, "inappropriate permissions on device!");
388 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
392 if (ftdi_usb_reset (ftdi) != 0) {
393 usb_close (ftdi->usb_dev);
394 ftdi_error_return(-6, "ftdi_usb_reset failed");
397 if (ftdi_set_baudrate (ftdi, 9600) != 0) {
398 usb_close (ftdi->usb_dev);
399 ftdi_error_return(-7, "set baudrate failed");
402 // Try to guess chip type
403 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
404 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
405 && dev->descriptor.iSerialNumber == 0))
406 ftdi->type = TYPE_BM;
407 else if (dev->descriptor.bcdDevice == 0x200)
408 ftdi->type = TYPE_AM;
409 else if (dev->descriptor.bcdDevice == 0x500) {
410 ftdi->type = TYPE_2232C;
412 ftdi->index = INTERFACE_A;
413 } else if (dev->descriptor.bcdDevice == 0x600)
416 ftdi_error_return(0, "all fine");
420 Opens the first device with a given vendor and product ids.
422 \param ftdi pointer to ftdi_context
423 \param vendor Vendor ID
424 \param product Product ID
426 \retval same as ftdi_usb_open_desc()
428 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
430 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
434 Opens the first device with a given, vendor id, product id,
435 description and serial.
437 \param ftdi pointer to ftdi_context
438 \param vendor Vendor ID
439 \param product Product ID
440 \param description Description to search for. Use NULL if not needed.
441 \param serial Serial to search for. Use NULL if not needed.
444 \retval -1: usb_find_busses() failed
445 \retval -2: usb_find_devices() failed
446 \retval -3: usb device not found
447 \retval -4: unable to open device
448 \retval -5: unable to claim device
449 \retval -6: reset failed
450 \retval -7: set baudrate failed
451 \retval -8: get product description failed
452 \retval -9: get serial number failed
453 \retval -10: unable to close device
455 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
456 const char* description, const char* serial)
459 struct usb_device *dev;
464 if (usb_find_busses() < 0)
465 ftdi_error_return(-1, "usb_find_busses() failed");
466 if (usb_find_devices() < 0)
467 ftdi_error_return(-2, "usb_find_devices() failed");
469 for (bus = usb_get_busses(); bus; bus = bus->next) {
470 for (dev = bus->devices; dev; dev = dev->next) {
471 if (dev->descriptor.idVendor == vendor
472 && dev->descriptor.idProduct == product) {
473 if (!(ftdi->usb_dev = usb_open(dev)))
474 ftdi_error_return(-4, "usb_open() failed");
476 if (description != NULL) {
477 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) {
478 usb_close (ftdi->usb_dev);
479 ftdi_error_return(-8, "unable to fetch product description");
481 if (strncmp(string, description, sizeof(string)) != 0) {
482 if (usb_close (ftdi->usb_dev) != 0)
483 ftdi_error_return(-10, "unable to close device");
487 if (serial != NULL) {
488 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) {
489 usb_close (ftdi->usb_dev);
490 ftdi_error_return(-9, "unable to fetch serial number");
492 if (strncmp(string, serial, sizeof(string)) != 0) {
493 if (usb_close (ftdi->usb_dev) != 0)
494 ftdi_error_return(-10, "unable to close device");
499 if (usb_close (ftdi->usb_dev) != 0)
500 ftdi_error_return(-10, "unable to close device");
502 return ftdi_usb_open_dev(ftdi, dev);
508 ftdi_error_return(-3, "device not found");
512 Resets the ftdi device.
514 \param ftdi pointer to ftdi_context
517 \retval -1: FTDI reset failed
519 int ftdi_usb_reset(struct ftdi_context *ftdi)
521 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
522 ftdi_error_return(-1,"FTDI reset failed");
524 // Invalidate data in the readbuffer
525 ftdi->readbuffer_offset = 0;
526 ftdi->readbuffer_remaining = 0;
532 Clears the read buffer on the chip and the internal read buffer.
534 \param ftdi pointer to ftdi_context
537 \retval -1: read buffer purge failed
539 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
541 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
542 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
544 // Invalidate data in the readbuffer
545 ftdi->readbuffer_offset = 0;
546 ftdi->readbuffer_remaining = 0;
552 Clears the write buffer on the chip.
554 \param ftdi pointer to ftdi_context
557 \retval -1: write buffer purge failed
559 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
561 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
562 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
568 Clears the buffers on the chip and the internal read buffer.
570 \param ftdi pointer to ftdi_context
573 \retval -1: read buffer purge failed
574 \retval -2: write buffer purge failed
576 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
580 result = ftdi_usb_purge_rx_buffer(ftdi);
584 result = ftdi_usb_purge_tx_buffer(ftdi);
592 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
594 \param ftdi pointer to ftdi_context
597 \retval -1: usb_release failed
598 \retval -2: usb_close failed
600 int ftdi_usb_close(struct ftdi_context *ftdi)
604 #ifdef LIBFTDI_LINUX_ASYNC_MODE
605 /* try to release some kernel resources */
606 ftdi_async_complete(ftdi,1);
609 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
612 if (usb_close (ftdi->usb_dev) != 0)
619 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
620 Function is only used internally
623 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
624 unsigned short *value, unsigned short *index)
626 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
627 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
628 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
629 int divisor, best_divisor, best_baud, best_baud_diff;
630 unsigned long encoded_divisor;
638 divisor = 24000000 / baudrate;
640 if (ftdi->type == TYPE_AM) {
641 // Round down to supported fraction (AM only)
642 divisor -= am_adjust_dn[divisor & 7];
645 // Try this divisor and the one above it (because division rounds down)
649 for (i = 0; i < 2; i++) {
650 int try_divisor = divisor + i;
654 // Round up to supported divisor value
655 if (try_divisor <= 8) {
656 // Round up to minimum supported divisor
658 } else if (ftdi->type != TYPE_AM && try_divisor < 12) {
659 // BM doesn't support divisors 9 through 11 inclusive
661 } else if (divisor < 16) {
662 // AM doesn't support divisors 9 through 15 inclusive
665 if (ftdi->type == TYPE_AM) {
666 // Round up to supported fraction (AM only)
667 try_divisor += am_adjust_up[try_divisor & 7];
668 if (try_divisor > 0x1FFF8) {
669 // Round down to maximum supported divisor value (for AM)
670 try_divisor = 0x1FFF8;
673 if (try_divisor > 0x1FFFF) {
674 // Round down to maximum supported divisor value (for BM)
675 try_divisor = 0x1FFFF;
679 // Get estimated baud rate (to nearest integer)
680 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
681 // Get absolute difference from requested baud rate
682 if (baud_estimate < baudrate) {
683 baud_diff = baudrate - baud_estimate;
685 baud_diff = baud_estimate - baudrate;
687 if (i == 0 || baud_diff < best_baud_diff) {
688 // Closest to requested baud rate so far
689 best_divisor = try_divisor;
690 best_baud = baud_estimate;
691 best_baud_diff = baud_diff;
692 if (baud_diff == 0) {
693 // Spot on! No point trying
698 // Encode the best divisor value
699 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
700 // Deal with special cases for encoded value
701 if (encoded_divisor == 1) {
702 encoded_divisor = 0; // 3000000 baud
703 } else if (encoded_divisor == 0x4001) {
704 encoded_divisor = 1; // 2000000 baud (BM only)
706 // Split into "value" and "index" values
707 *value = (unsigned short)(encoded_divisor & 0xFFFF);
708 if(ftdi->type == TYPE_2232C) {
709 *index = (unsigned short)(encoded_divisor >> 8);
711 *index |= ftdi->index;
714 *index = (unsigned short)(encoded_divisor >> 16);
716 // Return the nearest baud rate
721 Sets the chip baud rate
723 \param ftdi pointer to ftdi_context
724 \param baudrate baud rate to set
727 \retval -1: invalid baudrate
728 \retval -2: setting baudrate failed
730 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
732 unsigned short value, index;
735 if (ftdi->bitbang_enabled) {
736 baudrate = baudrate*4;
739 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
740 if (actual_baudrate <= 0)
741 ftdi_error_return (-1, "Silly baudrate <= 0.");
743 // Check within tolerance (about 5%)
744 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
745 || ((actual_baudrate < baudrate)
746 ? (actual_baudrate * 21 < baudrate * 20)
747 : (baudrate * 21 < actual_baudrate * 20)))
748 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
750 if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0)
751 ftdi_error_return (-2, "Setting new baudrate failed");
753 ftdi->baudrate = baudrate;
758 Set (RS232) line characteristics.
759 The break type can only be set via ftdi_set_line_property2()
760 and defaults to "off".
762 \param ftdi pointer to ftdi_context
763 \param bits Number of bits
764 \param sbit Number of stop bits
765 \param parity Parity mode
768 \retval -1: Setting line property failed
770 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
771 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
773 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
777 Set (RS232) line characteristics
779 \param ftdi pointer to ftdi_context
780 \param bits Number of bits
781 \param sbit Number of stop bits
782 \param parity Parity mode
783 \param break_type Break type
786 \retval -1: Setting line property failed
788 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
789 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
790 enum ftdi_break_type break_type)
792 unsigned short value = bits;
796 value |= (0x00 << 8);
799 value |= (0x01 << 8);
802 value |= (0x02 << 8);
805 value |= (0x03 << 8);
808 value |= (0x04 << 8);
814 value |= (0x00 << 11);
817 value |= (0x01 << 11);
820 value |= (0x02 << 11);
826 value |= (0x00 << 14);
829 value |= (0x01 << 14);
833 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
834 ftdi_error_return (-1, "Setting new line property failed");
840 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
842 \param ftdi pointer to ftdi_context
843 \param buf Buffer with the data
844 \param size Size of the buffer
846 \retval <0: error code from usb_bulk_write()
847 \retval >0: number of bytes written
849 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
853 int total_written = 0;
855 while (offset < size) {
856 int write_size = ftdi->writebuffer_chunksize;
858 if (offset+write_size > size)
859 write_size = size-offset;
861 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
863 ftdi_error_return(ret, "usb bulk write failed");
865 total_written += ret;
866 offset += write_size;
869 return total_written;
872 #ifdef LIBFTDI_LINUX_ASYNC_MODE
873 /* this is strongly dependent on libusb using the same struct layout. If libusb
874 changes in some later version this may break horribly (this is for libusb 0.1.12) */
875 struct usb_dev_handle {
877 // some other stuff coming here we don't need
881 Check for pending async urbs
884 static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
886 struct usbdevfs_urb *urb;
890 for (i=0; i < ftdi->async_usb_buffer_size; i++) {
891 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
892 if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
900 Wait until one or more async URBs are completed by the kernel and mark their
901 positions in the async-buffer as unused
903 \param ftdi pointer to ftdi_context
904 \param wait_for_more if != 0 wait for more than one write to complete
905 \param timeout_msec max milliseconds to wait
909 static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
912 struct usbdevfs_urb *urb=NULL;
918 FD_SET(ftdi->usb_dev->fd, &writefds);
920 /* init timeout only once, select writes time left after call */
921 tv.tv_sec = timeout_msec / 1000;
922 tv.tv_usec = (timeout_msec % 1000) * 1000;
925 while (_usb_get_async_urbs_pending(ftdi)
926 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
929 if (keep_going && !wait_for_more) {
930 /* don't wait if repeating only for keep_going */
935 /* wait for timeout msec or something written ready */
936 select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
939 if (ret == 0 && urb != NULL) {
940 /* got a free urb, mark it */
941 urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
943 /* try to get more urbs that are ready now, but don't wait anymore */
947 /* no more urbs waiting */
950 } while (keep_going);
954 Wait until one or more async URBs are completed by the kernel and mark their
955 positions in the async-buffer as unused.
957 \param ftdi pointer to ftdi_context
958 \param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
960 void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
962 _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
966 Stupid libusb does not offer async writes nor does it allow
967 access to its fd - so we need some hacks here.
970 static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
972 struct usbdevfs_urb *urb;
973 int bytesdone = 0, requested;
978 /* find a free urb buffer we can use */
980 for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
982 if (i==ftdi->async_usb_buffer_size) {
983 /* wait until some buffers are free */
984 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
987 for (i=0; i < ftdi->async_usb_buffer_size; i++) {
988 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
989 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
990 break; /* found a free urb position */
995 /* no free urb position found */
999 requested = size - bytesdone;
1000 if (requested > 4096)
1003 memset(urb,0,sizeof(urb));
1005 urb->type = USBDEVFS_URB_TYPE_BULK;
1008 urb->buffer = bytes + bytesdone;
1009 urb->buffer_length = requested;
1011 urb->actual_length = 0;
1012 urb->number_of_packets = 0;
1013 urb->usercontext = 0;
1016 ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
1017 } while (ret < 0 && errno == EINTR);
1019 return ret; /* the caller can read errno to get more info */
1021 bytesdone += requested;
1022 } while (bytesdone < size);
1027 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
1028 Does not wait for completion of the transfer nor does it make sure that
1029 the transfer was successful.
1031 This function could be extended to use signals and callbacks to inform the
1032 caller of completion or error - but this is not done yet, volunteers welcome.
1034 Works around libusb and directly accesses functions only available on Linux.
1035 Only available if compiled with --with-async-mode.
1037 \param ftdi pointer to ftdi_context
1038 \param buf Buffer with the data
1039 \param size Size of the buffer
1041 \retval <0: error code from usb_bulk_write()
1042 \retval >0: number of bytes written
1044 int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
1048 int total_written = 0;
1050 while (offset < size) {
1051 int write_size = ftdi->writebuffer_chunksize;
1053 if (offset+write_size > size)
1054 write_size = size-offset;
1056 ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
1058 ftdi_error_return(ret, "usb bulk write async failed");
1060 total_written += ret;
1061 offset += write_size;
1064 return total_written;
1066 #endif // LIBFTDI_LINUX_ASYNC_MODE
1069 Configure write buffer chunk size.
1072 \param ftdi pointer to ftdi_context
1073 \param chunksize Chunk size
1077 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1079 ftdi->writebuffer_chunksize = chunksize;
1084 Get write buffer chunk size.
1086 \param ftdi pointer to ftdi_context
1087 \param chunksize Pointer to store chunk size in
1091 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1093 *chunksize = ftdi->writebuffer_chunksize;
1098 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1100 Automatically strips the two modem status bytes transfered during every read.
1102 \param ftdi pointer to ftdi_context
1103 \param buf Buffer to store data in
1104 \param size Size of the buffer
1106 \retval <0: error code from usb_bulk_read()
1107 \retval 0: no data was available
1108 \retval >0: number of bytes read
1110 \remark This function is not useful in bitbang mode.
1111 Use ftdi_read_pins() to get the current state of the pins.
1113 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1115 int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
1117 // everything we want is still in the readbuffer?
1118 if (size <= ftdi->readbuffer_remaining) {
1119 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1122 ftdi->readbuffer_remaining -= size;
1123 ftdi->readbuffer_offset += size;
1125 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1129 // something still in the readbuffer, but not enough to satisfy 'size'?
1130 if (ftdi->readbuffer_remaining != 0) {
1131 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1134 offset += ftdi->readbuffer_remaining;
1136 // do the actual USB read
1137 while (offset < size && ret > 0) {
1138 ftdi->readbuffer_remaining = 0;
1139 ftdi->readbuffer_offset = 0;
1140 /* returns how much received */
1141 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
1143 ftdi_error_return(ret, "usb bulk read failed");
1146 // skip FTDI status bytes.
1147 // Maybe stored in the future to enable modem use
1148 num_of_chunks = ret / 64;
1149 chunk_remains = ret % 64;
1150 //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1152 ftdi->readbuffer_offset += 2;
1156 for (i = 1; i < num_of_chunks; i++)
1157 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
1158 ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
1160 if (chunk_remains > 2) {
1161 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
1162 ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
1164 ret -= 2*num_of_chunks;
1166 ret -= 2*(num_of_chunks-1)+chunk_remains;
1168 } else if (ret <= 2) {
1169 // no more data to read?
1173 // data still fits in buf?
1174 if (offset+ret <= size) {
1175 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
1176 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1179 /* Did we read exactly the right amount of bytes? */
1181 //printf("read_data exact rem %d offset %d\n",
1182 //ftdi->readbuffer_remaining, offset);
1185 // only copy part of the data or size <= readbuffer_chunksize
1186 int part_size = size-offset;
1187 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1189 ftdi->readbuffer_offset += part_size;
1190 ftdi->readbuffer_remaining = ret-part_size;
1191 offset += part_size;
1193 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
1194 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
1205 Configure read buffer chunk size.
1208 Automatically reallocates the buffer.
1210 \param ftdi pointer to ftdi_context
1211 \param chunksize Chunk size
1215 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1217 unsigned char *new_buf;
1219 // Invalidate all remaining data
1220 ftdi->readbuffer_offset = 0;
1221 ftdi->readbuffer_remaining = 0;
1223 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1224 ftdi_error_return(-1, "out of memory for readbuffer");
1226 ftdi->readbuffer = new_buf;
1227 ftdi->readbuffer_chunksize = chunksize;
1233 Get read buffer chunk size.
1235 \param ftdi pointer to ftdi_context
1236 \param chunksize Pointer to store chunk size in
1240 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1242 *chunksize = ftdi->readbuffer_chunksize;
1248 Enable bitbang mode.
1250 For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
1252 \param ftdi pointer to ftdi_context
1253 \param bitmask Bitmask to configure lines.
1254 HIGH/ON value configures a line as output.
1257 \retval -1: can't enable bitbang mode
1259 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1261 unsigned short usb_val;
1263 usb_val = bitmask; // low byte: bitmask
1264 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1265 usb_val |= (ftdi->bitbang_mode << 8);
1267 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1268 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1270 ftdi->bitbang_enabled = 1;
1275 Disable bitbang mode.
1277 \param ftdi pointer to ftdi_context
1280 \retval -1: can't disable bitbang mode
1282 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1284 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1285 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1287 ftdi->bitbang_enabled = 0;
1292 Enable advanced bitbang mode for FT2232C chips.
1294 \param ftdi pointer to ftdi_context
1295 \param bitmask Bitmask to configure lines.
1296 HIGH/ON value configures a line as output.
1297 \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
1300 \retval -1: can't enable bitbang mode
1302 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1304 unsigned short usb_val;
1306 usb_val = bitmask; // low byte: bitmask
1307 usb_val |= (mode << 8);
1308 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1309 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1311 ftdi->bitbang_mode = mode;
1312 ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
1317 Directly read pin state. Useful for bitbang mode.
1319 \param ftdi pointer to ftdi_context
1320 \param pins Pointer to store pins into
1323 \retval -1: read pins failed
1325 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1327 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
1328 ftdi_error_return(-1, "read pins failed");
1336 The FTDI chip keeps data in the internal buffer for a specific
1337 amount of time if the buffer is not full yet to decrease
1338 load on the usb bus.
1340 \param ftdi pointer to ftdi_context
1341 \param latency Value between 1 and 255
1344 \retval -1: latency out of range
1345 \retval -2: unable to set latency timer
1347 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1349 unsigned short usb_val;
1352 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1355 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1356 ftdi_error_return(-2, "unable to set latency timer");
1364 \param ftdi pointer to ftdi_context
1365 \param latency Pointer to store latency value in
1368 \retval -1: unable to get latency timer
1370 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1372 unsigned short usb_val;
1373 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1374 ftdi_error_return(-1, "reading latency timer failed");
1376 *latency = (unsigned char)usb_val;
1381 Poll modem status information
1383 This function allows the retrieve the two status bytes of the device.
1384 The device sends these bytes also as a header for each read access
1385 where they are discarded by ftdi_read_data(). The chip generates
1386 the two stripped status bytes in the absence of data every 40 ms.
1388 Layout of the first byte:
1389 - B0..B3 - must be 0
1390 - B4 Clear to send (CTS)
1393 - B5 Data set ready (DTS)
1396 - B6 Ring indicator (RI)
1399 - B7 Receive line signal detect (RLSD)
1403 Layout of the second byte:
1404 - B0 Data ready (DR)
1405 - B1 Overrun error (OE)
1406 - B2 Parity error (PE)
1407 - B3 Framing error (FE)
1408 - B4 Break interrupt (BI)
1409 - B5 Transmitter holding register (THRE)
1410 - B6 Transmitter empty (TEMT)
1411 - B7 Error in RCVR FIFO
1413 \param ftdi pointer to ftdi_context
1414 \param status Pointer to store status information in. Must be two bytes.
1417 \retval -1: unable to retrieve status information
1419 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1423 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
1424 ftdi_error_return(-1, "getting modem status failed");
1426 *status = (usb_val[1] << 8) | usb_val[0];
1433 Flow control code by Lorenz Moesenlechner (lorenz@hcilab.org)
1434 and Matthias Kranz (matthias@hcilab.org)
1437 Set flowcontrol for ftdi chip
1439 \param ftdi pointer to ftdi_context
1440 \param flowctrl flow control to use. should be
1441 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1444 \retval -1: set flow control failed
1446 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1448 if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1449 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->interface),
1450 NULL, 0, ftdi->usb_write_timeout) != 0)
1451 ftdi_error_return(-1, "set flow control failed");
1459 \param ftdi pointer to ftdi_context
1460 \param state state to set line to (1 or 0)
1463 \retval -1: set dtr failed
1465 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1467 unsigned short usb_val;
1470 usb_val = SIO_SET_DTR_HIGH;
1472 usb_val = SIO_SET_DTR_LOW;
1474 if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1475 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
1476 NULL, 0, ftdi->usb_write_timeout) != 0)
1477 ftdi_error_return(-1, "set dtr failed");
1485 \param ftdi pointer to ftdi_context
1486 \param state state to set line to (1 or 0)
1489 \retval -1 set rts failed
1491 int ftdi_setrts(struct ftdi_context *ftdi, int state)
1493 unsigned short usb_val;
1496 usb_val = SIO_SET_RTS_HIGH;
1498 usb_val = SIO_SET_RTS_LOW;
1500 if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1501 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
1502 NULL, 0, ftdi->usb_write_timeout) != 0)
1503 ftdi_error_return(-1, "set of rts failed");
1509 Set the special event character
1511 \param ftdi pointer to ftdi_context
1512 \param eventch Event character
1513 \param enable 0 to disable the event character, non-zero otherwise
1516 \retval -1: unable to set event character
1518 int ftdi_set_event_char(struct ftdi_context *ftdi,
1519 unsigned char eventch, unsigned char enable)
1521 unsigned short usb_val;
1527 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x06, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1528 ftdi_error_return(-1, "setting event character failed");
1536 \param ftdi pointer to ftdi_context
1537 \param errorch Error character
1538 \param enable 0 to disable the error character, non-zero otherwise
1541 \retval -1: unable to set error character
1543 int ftdi_set_error_char(struct ftdi_context *ftdi,
1544 unsigned char errorch, unsigned char enable)
1546 unsigned short usb_val;
1552 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x07, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1553 ftdi_error_return(-1, "setting error character failed");
1561 \param ftdi pointer to ftdi_context
1562 \param eeprom Pointer to ftdi_eeprom
1566 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
1568 ftdi->eeprom_size=size;
1573 Init eeprom with default values.
1575 \param eeprom Pointer to ftdi_eeprom
1577 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
1579 eeprom->vendor_id = 0x0403;
1580 eeprom->product_id = 0x6001;
1582 eeprom->self_powered = 1;
1583 eeprom->remote_wakeup = 1;
1584 eeprom->BM_type_chip = 1;
1586 eeprom->in_is_isochronous = 0;
1587 eeprom->out_is_isochronous = 0;
1588 eeprom->suspend_pull_downs = 0;
1590 eeprom->use_serial = 0;
1591 eeprom->change_usb_version = 0;
1592 eeprom->usb_version = 0x0200;
1593 eeprom->max_power = 0;
1595 eeprom->manufacturer = NULL;
1596 eeprom->product = NULL;
1597 eeprom->serial = NULL;
1599 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
1603 Build binary output from ftdi_eeprom structure.
1604 Output is suitable for ftdi_write_eeprom().
1606 \param eeprom Pointer to ftdi_eeprom
1607 \param output Buffer of 128 bytes to store eeprom image to
1609 \retval >0: used eeprom size
1610 \retval -1: eeprom size (128 bytes) exceeded by custom strings
1612 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
1615 unsigned short checksum, value;
1616 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1619 if (eeprom->manufacturer != NULL)
1620 manufacturer_size = strlen(eeprom->manufacturer);
1621 if (eeprom->product != NULL)
1622 product_size = strlen(eeprom->product);
1623 if (eeprom->serial != NULL)
1624 serial_size = strlen(eeprom->serial);
1626 size_check = eeprom->size;
1627 size_check -= 28; // 28 are always in use (fixed)
1629 // Top half of a 256byte eeprom is used just for strings and checksum
1630 // it seems that the FTDI chip will not read these strings from the lower half
1631 // Each string starts with two bytes; offset and type (0x03 for string)
1632 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1633 if(eeprom->size>=256)size_check = 120;
1634 size_check -= manufacturer_size*2;
1635 size_check -= product_size*2;
1636 size_check -= serial_size*2;
1638 // eeprom size exceeded?
1643 memset (output, 0, eeprom->size);
1645 // Addr 00: Stay 00 00
1646 // Addr 02: Vendor ID
1647 output[0x02] = eeprom->vendor_id;
1648 output[0x03] = eeprom->vendor_id >> 8;
1650 // Addr 04: Product ID
1651 output[0x04] = eeprom->product_id;
1652 output[0x05] = eeprom->product_id >> 8;
1654 // Addr 06: Device release number (0400h for BM features)
1655 output[0x06] = 0x00;
1657 if (eeprom->BM_type_chip == 1)
1658 output[0x07] = 0x04;
1660 output[0x07] = 0x02;
1662 // Addr 08: Config descriptor
1664 // Bit 6: 1 if this device is self powered, 0 if bus powered
1665 // Bit 5: 1 if this device uses remote wakeup
1666 // Bit 4: 1 if this device is battery powered
1668 if (eeprom->self_powered == 1)
1670 if (eeprom->remote_wakeup == 1)
1674 // Addr 09: Max power consumption: max power = value * 2 mA
1675 output[0x09] = eeprom->max_power;
1677 // Addr 0A: Chip configuration
1678 // Bit 7: 0 - reserved
1679 // Bit 6: 0 - reserved
1680 // Bit 5: 0 - reserved
1681 // Bit 4: 1 - Change USB version
1682 // Bit 3: 1 - Use the serial number string
1683 // Bit 2: 1 - Enable suspend pull downs for lower power
1684 // Bit 1: 1 - Out EndPoint is Isochronous
1685 // Bit 0: 1 - In EndPoint is Isochronous
1688 if (eeprom->in_is_isochronous == 1)
1690 if (eeprom->out_is_isochronous == 1)
1692 if (eeprom->suspend_pull_downs == 1)
1694 if (eeprom->use_serial == 1)
1696 if (eeprom->change_usb_version == 1)
1700 // Addr 0B: reserved
1701 output[0x0B] = 0x00;
1703 // Addr 0C: USB version low byte when 0x0A bit 4 is set
1704 // Addr 0D: USB version high byte when 0x0A bit 4 is set
1705 if (eeprom->change_usb_version == 1) {
1706 output[0x0C] = eeprom->usb_version;
1707 output[0x0D] = eeprom->usb_version >> 8;
1711 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
1712 // Addr 0F: Length of manufacturer string
1713 output[0x0F] = manufacturer_size*2 + 2;
1715 // Addr 10: Offset of the product string + 0x80, calculated later
1716 // Addr 11: Length of product string
1717 output[0x11] = product_size*2 + 2;
1719 // Addr 12: Offset of the serial string + 0x80, calculated later
1720 // Addr 13: Length of serial string
1721 output[0x13] = serial_size*2 + 2;
1725 if(eeprom->size>=256) i = 0x80;
1728 // Output manufacturer
1729 output[0x0E] = i | 0x80; // calculate offset
1730 output[i++] = manufacturer_size*2 + 2;
1731 output[i++] = 0x03; // type: string
1732 for (j = 0; j < manufacturer_size; j++) {
1733 output[i] = eeprom->manufacturer[j], i++;
1734 output[i] = 0x00, i++;
1737 // Output product name
1738 output[0x10] = i | 0x80; // calculate offset
1739 output[i] = product_size*2 + 2, i++;
1740 output[i] = 0x03, i++;
1741 for (j = 0; j < product_size; j++) {
1742 output[i] = eeprom->product[j], i++;
1743 output[i] = 0x00, i++;
1747 output[0x12] = i | 0x80; // calculate offset
1748 output[i] = serial_size*2 + 2, i++;
1749 output[i] = 0x03, i++;
1750 for (j = 0; j < serial_size; j++) {
1751 output[i] = eeprom->serial[j], i++;
1752 output[i] = 0x00, i++;
1755 // calculate checksum
1758 for (i = 0; i < eeprom->size/2-1; i++) {
1759 value = output[i*2];
1760 value += output[(i*2)+1] << 8;
1762 checksum = value^checksum;
1763 checksum = (checksum << 1) | (checksum >> 15);
1766 output[eeprom->size-2] = checksum;
1767 output[eeprom->size-1] = checksum >> 8;
1775 \param ftdi pointer to ftdi_context
1776 \param eeprom Pointer to store eeprom into
1779 \retval -1: read failed
1781 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
1785 for (i = 0; i < ftdi->eeprom_size/2; i++) {
1786 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
1787 ftdi_error_return(-1, "reading eeprom failed");
1794 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
1795 Function is only used internally
1798 static unsigned char ftdi_read_chipid_shift(unsigned char value)
1800 return ((value & 1) << 1) |
1801 ((value & 2) << 5) |
1802 ((value & 4) >> 2) |
1803 ((value & 8) << 4) |
1804 ((value & 16) >> 1) |
1805 ((value & 32) >> 1) |
1806 ((value & 64) >> 4) |
1807 ((value & 128) >> 2);
1811 Read the FTDIChip-ID from R-type devices
1813 \param ftdi pointer to ftdi_context
1814 \param chipid Pointer to store FTDIChip-ID
1817 \retval -1: read failed
1819 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
1821 unsigned int a = 0, b = 0;
1823 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
1825 a = a << 8 | a >> 8;
1826 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
1828 b = b << 8 | b >> 8;
1830 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
1831 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
1832 *chipid = a ^ 0xa5f0f7d1;
1837 ftdi_error_return(-1, "read of FTDIChip-ID failed");
1841 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
1842 Call this function then do a write then call again to see if size changes, if so write again.
1844 \param ftdi pointer to ftdi_context
1845 \param eeprom Pointer to store eeprom into
1846 \param maxsize the size of the buffer to read into
1848 \retval size of eeprom
1850 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
1852 int i=0,j,minsize=32;
1856 for (j = 0; i < maxsize/2 && j<size; j++) {
1857 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
1858 ftdi_error_return(-1, "reading eeprom failed");
1862 }while(size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
1870 \param ftdi pointer to ftdi_context
1871 \param eeprom Pointer to read eeprom from
1874 \retval -1: read failed
1876 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
1878 unsigned short usb_val;
1881 for (i = 0; i < ftdi->eeprom_size/2; i++) {
1882 usb_val = eeprom[i*2];
1883 usb_val += eeprom[(i*2)+1] << 8;
1884 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0)
1885 ftdi_error_return(-1, "unable to write eeprom");
1894 \param ftdi pointer to ftdi_context
1897 \retval -1: erase failed
1899 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
1901 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
1902 ftdi_error_return(-1, "unable to erase eeprom");
1908 Get string representation for last error code
1910 \param ftdi pointer to ftdi_context
1912 \retval Pointer to error string
1914 char *ftdi_get_error_string (struct ftdi_context *ftdi)
1916 return ftdi->error_str;
1919 /* @} end of doxygen libftdi group */