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_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 -4: unable to open device
345 \retval -5: unable to claim device
346 \retval -6: reset failed
347 \retval -7: set baudrate failed
349 int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
351 int detach_errno = 0;
352 if (!(ftdi->usb_dev = usb_open(dev)))
353 ftdi_error_return(-4, "usb_open() failed");
355 #ifdef LIBUSB_HAS_GET_DRIVER_NP
356 // Try to detach ftdi_sio kernel module
357 // Returns ENODATA if driver is not loaded
358 if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
359 detach_errno = errno;
362 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
363 usb_close (ftdi->usb_dev);
364 if (detach_errno == EPERM) {
365 ftdi_error_return(-8, "inappropriate permissions on device!");
367 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
371 if (ftdi_usb_reset (ftdi) != 0) {
372 usb_close (ftdi->usb_dev);
373 ftdi_error_return(-6, "ftdi_usb_reset failed");
376 if (ftdi_set_baudrate (ftdi, 9600) != 0) {
377 usb_close (ftdi->usb_dev);
378 ftdi_error_return(-7, "set baudrate failed");
381 // Try to guess chip type
382 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
383 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
384 && dev->descriptor.iSerialNumber == 0))
385 ftdi->type = TYPE_BM;
386 else if (dev->descriptor.bcdDevice == 0x200)
387 ftdi->type = TYPE_AM;
388 else if (dev->descriptor.bcdDevice == 0x500) {
389 ftdi->type = TYPE_2232C;
391 ftdi->index = INTERFACE_A;
392 } else if (dev->descriptor.bcdDevice == 0x600)
395 ftdi_error_return(0, "all fine");
399 Opens the first device with a given vendor and product ids.
401 \param ftdi pointer to ftdi_context
402 \param vendor Vendor ID
403 \param product Product ID
405 \retval same as ftdi_usb_open_desc()
407 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
409 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
413 Opens the first device with a given, vendor id, product id,
414 description and serial.
416 \param ftdi pointer to ftdi_context
417 \param vendor Vendor ID
418 \param product Product ID
419 \param description Description to search for. Use NULL if not needed.
420 \param serial Serial to search for. Use NULL if not needed.
423 \retval -1: usb_find_busses() failed
424 \retval -2: usb_find_devices() failed
425 \retval -3: usb device not found
426 \retval -4: unable to open device
427 \retval -5: unable to claim device
428 \retval -6: reset failed
429 \retval -7: set baudrate failed
430 \retval -8: get product description failed
431 \retval -9: get serial number failed
432 \retval -10: unable to close device
434 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
435 const char* description, const char* serial)
438 struct usb_device *dev;
443 if (usb_find_busses() < 0)
444 ftdi_error_return(-1, "usb_find_busses() failed");
445 if (usb_find_devices() < 0)
446 ftdi_error_return(-2, "usb_find_devices() failed");
448 for (bus = usb_busses; bus; bus = bus->next) {
449 for (dev = bus->devices; dev; dev = dev->next) {
450 if (dev->descriptor.idVendor == vendor
451 && dev->descriptor.idProduct == product) {
452 if (!(ftdi->usb_dev = usb_open(dev)))
453 ftdi_error_return(-4, "usb_open() failed");
455 if (description != NULL) {
456 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) {
457 usb_close (ftdi->usb_dev);
458 ftdi_error_return(-8, "unable to fetch product description");
460 if (strncmp(string, description, sizeof(string)) != 0) {
461 if (usb_close (ftdi->usb_dev) != 0)
462 ftdi_error_return(-10, "unable to close device");
466 if (serial != NULL) {
467 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) {
468 usb_close (ftdi->usb_dev);
469 ftdi_error_return(-9, "unable to fetch serial number");
471 if (strncmp(string, serial, sizeof(string)) != 0) {
472 if (usb_close (ftdi->usb_dev) != 0)
473 ftdi_error_return(-10, "unable to close device");
478 if (usb_close (ftdi->usb_dev) != 0)
479 ftdi_error_return(-10, "unable to close device");
481 return ftdi_usb_open_dev(ftdi, dev);
487 ftdi_error_return(-3, "device not found");
491 Resets the ftdi device.
493 \param ftdi pointer to ftdi_context
496 \retval -1: FTDI reset failed
498 int ftdi_usb_reset(struct ftdi_context *ftdi)
500 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
501 ftdi_error_return(-1,"FTDI reset failed");
503 // Invalidate data in the readbuffer
504 ftdi->readbuffer_offset = 0;
505 ftdi->readbuffer_remaining = 0;
511 Clears the read buffer on the chip and the internal read buffer.
513 \param ftdi pointer to ftdi_context
516 \retval -1: read buffer purge failed
518 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
520 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
521 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
523 // Invalidate data in the readbuffer
524 ftdi->readbuffer_offset = 0;
525 ftdi->readbuffer_remaining = 0;
531 Clears the write buffer on the chip.
533 \param ftdi pointer to ftdi_context
536 \retval -1: write buffer purge failed
538 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
540 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
541 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
547 Clears the buffers on the chip and the internal read buffer.
549 \param ftdi pointer to ftdi_context
552 \retval -1: read buffer purge failed
553 \retval -2: write buffer purge failed
555 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
559 result = ftdi_usb_purge_rx_buffer(ftdi);
563 result = ftdi_usb_purge_tx_buffer(ftdi);
571 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
573 \param ftdi pointer to ftdi_context
576 \retval -1: usb_release failed
577 \retval -2: usb_close failed
579 int ftdi_usb_close(struct ftdi_context *ftdi)
583 #ifdef LIBFTDI_LINUX_ASYNC_MODE
584 /* try to release some kernel resources */
585 ftdi_async_complete(ftdi,1);
588 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
591 if (usb_close (ftdi->usb_dev) != 0)
598 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
599 Function is only used internally
602 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
603 unsigned short *value, unsigned short *index)
605 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
606 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
607 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
608 int divisor, best_divisor, best_baud, best_baud_diff;
609 unsigned long encoded_divisor;
617 divisor = 24000000 / baudrate;
619 if (ftdi->type == TYPE_AM) {
620 // Round down to supported fraction (AM only)
621 divisor -= am_adjust_dn[divisor & 7];
624 // Try this divisor and the one above it (because division rounds down)
628 for (i = 0; i < 2; i++) {
629 int try_divisor = divisor + i;
633 // Round up to supported divisor value
634 if (try_divisor <= 8) {
635 // Round up to minimum supported divisor
637 } else if (ftdi->type != TYPE_AM && try_divisor < 12) {
638 // BM doesn't support divisors 9 through 11 inclusive
640 } else if (divisor < 16) {
641 // AM doesn't support divisors 9 through 15 inclusive
644 if (ftdi->type == TYPE_AM) {
645 // Round up to supported fraction (AM only)
646 try_divisor += am_adjust_up[try_divisor & 7];
647 if (try_divisor > 0x1FFF8) {
648 // Round down to maximum supported divisor value (for AM)
649 try_divisor = 0x1FFF8;
652 if (try_divisor > 0x1FFFF) {
653 // Round down to maximum supported divisor value (for BM)
654 try_divisor = 0x1FFFF;
658 // Get estimated baud rate (to nearest integer)
659 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
660 // Get absolute difference from requested baud rate
661 if (baud_estimate < baudrate) {
662 baud_diff = baudrate - baud_estimate;
664 baud_diff = baud_estimate - baudrate;
666 if (i == 0 || baud_diff < best_baud_diff) {
667 // Closest to requested baud rate so far
668 best_divisor = try_divisor;
669 best_baud = baud_estimate;
670 best_baud_diff = baud_diff;
671 if (baud_diff == 0) {
672 // Spot on! No point trying
677 // Encode the best divisor value
678 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
679 // Deal with special cases for encoded value
680 if (encoded_divisor == 1) {
681 encoded_divisor = 0; // 3000000 baud
682 } else if (encoded_divisor == 0x4001) {
683 encoded_divisor = 1; // 2000000 baud (BM only)
685 // Split into "value" and "index" values
686 *value = (unsigned short)(encoded_divisor & 0xFFFF);
687 if(ftdi->type == TYPE_2232C) {
688 *index = (unsigned short)(encoded_divisor >> 8);
690 *index |= ftdi->index;
693 *index = (unsigned short)(encoded_divisor >> 16);
695 // Return the nearest baud rate
700 Sets the chip baud rate
702 \param ftdi pointer to ftdi_context
703 \param baudrate baud rate to set
706 \retval -1: invalid baudrate
707 \retval -2: setting baudrate failed
709 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
711 unsigned short value, index;
714 if (ftdi->bitbang_enabled) {
715 baudrate = baudrate*4;
718 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
719 if (actual_baudrate <= 0)
720 ftdi_error_return (-1, "Silly baudrate <= 0.");
722 // Check within tolerance (about 5%)
723 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
724 || ((actual_baudrate < baudrate)
725 ? (actual_baudrate * 21 < baudrate * 20)
726 : (baudrate * 21 < actual_baudrate * 20)))
727 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
729 if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0)
730 ftdi_error_return (-2, "Setting new baudrate failed");
732 ftdi->baudrate = baudrate;
737 Set (RS232) line characteristics by Alain Abbas
739 \param ftdi pointer to ftdi_context
740 \param bits Number of bits
741 \param sbit Number of stop bits
742 \param parity Parity mode
745 \retval -1: Setting line property failed
747 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
748 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
750 unsigned short value = bits;
754 value |= (0x00 << 8);
757 value |= (0x01 << 8);
760 value |= (0x02 << 8);
763 value |= (0x03 << 8);
766 value |= (0x04 << 8);
772 value |= (0x00 << 11);
775 value |= (0x01 << 11);
778 value |= (0x02 << 11);
782 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
783 ftdi_error_return (-1, "Setting new line property failed");
789 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
791 \param ftdi pointer to ftdi_context
792 \param buf Buffer with the data
793 \param size Size of the buffer
795 \retval <0: error code from usb_bulk_write()
796 \retval >0: number of bytes written
798 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
802 int total_written = 0;
804 while (offset < size) {
805 int write_size = ftdi->writebuffer_chunksize;
807 if (offset+write_size > size)
808 write_size = size-offset;
810 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
812 ftdi_error_return(ret, "usb bulk write failed");
814 total_written += ret;
815 offset += write_size;
818 return total_written;
821 #ifdef LIBFTDI_LINUX_ASYNC_MODE
822 /* this is strongly dependent on libusb using the same struct layout. If libusb
823 changes in some later version this may break horribly (this is for libusb 0.1.12) */
824 struct usb_dev_handle {
826 // some other stuff coming here we don't need
830 Check for pending async urbs
833 static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
835 struct usbdevfs_urb *urb;
839 for (i=0; i < ftdi->async_usb_buffer_size; i++) {
840 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
841 if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
849 Wait until one or more async URBs are completed by the kernel and mark their
850 positions in the async-buffer as unused
852 \param ftdi pointer to ftdi_context
853 \param wait_for_more if != 0 wait for more than one write to complete
854 \param timeout_msec max milliseconds to wait
858 static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
861 struct usbdevfs_urb *urb=NULL;
867 FD_SET(ftdi->usb_dev->fd, &writefds);
869 /* init timeout only once, select writes time left after call */
870 tv.tv_sec = timeout_msec / 1000;
871 tv.tv_usec = (timeout_msec % 1000) * 1000;
874 while (_usb_get_async_urbs_pending(ftdi)
875 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
878 if (keep_going && !wait_for_more) {
879 /* don't wait if repeating only for keep_going */
884 /* wait for timeout msec or something written ready */
885 select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
888 if (ret == 0 && urb != NULL) {
889 /* got a free urb, mark it */
890 urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
892 /* try to get more urbs that are ready now, but don't wait anymore */
896 /* no more urbs waiting */
899 } while (keep_going);
903 Wait until one or more async URBs are completed by the kernel and mark their
904 positions in the async-buffer as unused.
906 \param ftdi pointer to ftdi_context
907 \param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
909 void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
911 _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
915 Stupid libusb does not offer async writes nor does it allow
916 access to its fd - so we need some hacks here.
919 static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
921 struct usbdevfs_urb *urb;
922 int bytesdone = 0, requested;
927 /* find a free urb buffer we can use */
929 for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
931 if (i==ftdi->async_usb_buffer_size) {
932 /* wait until some buffers are free */
933 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
936 for (i=0; i < ftdi->async_usb_buffer_size; i++) {
937 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
938 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
939 break; /* found a free urb position */
944 /* no free urb position found */
948 requested = size - bytesdone;
949 if (requested > 4096)
952 memset(urb,0,sizeof(urb));
954 urb->type = USBDEVFS_URB_TYPE_BULK;
957 urb->buffer = bytes + bytesdone;
958 urb->buffer_length = requested;
960 urb->actual_length = 0;
961 urb->number_of_packets = 0;
962 urb->usercontext = 0;
965 ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
966 } while (ret < 0 && errno == EINTR);
968 return ret; /* the caller can read errno to get more info */
970 bytesdone += requested;
971 } while (bytesdone < size);
976 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
977 Does not wait for completion of the transfer nor does it make sure that
978 the transfer was successful.
980 This function could be extended to use signals and callbacks to inform the
981 caller of completion or error - but this is not done yet, volunteers welcome.
983 Works around libusb and directly accesses functions only available on Linux.
984 Only available if compiled with --with-async-mode.
986 \param ftdi pointer to ftdi_context
987 \param buf Buffer with the data
988 \param size Size of the buffer
990 \retval <0: error code from usb_bulk_write()
991 \retval >0: number of bytes written
993 int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
997 int total_written = 0;
999 while (offset < size) {
1000 int write_size = ftdi->writebuffer_chunksize;
1002 if (offset+write_size > size)
1003 write_size = size-offset;
1005 ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
1007 ftdi_error_return(ret, "usb bulk write async failed");
1009 total_written += ret;
1010 offset += write_size;
1013 return total_written;
1015 #endif // LIBFTDI_LINUX_ASYNC_MODE
1018 Configure write buffer chunk size.
1021 \param ftdi pointer to ftdi_context
1022 \param chunksize Chunk size
1026 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1028 ftdi->writebuffer_chunksize = chunksize;
1033 Get write buffer chunk size.
1035 \param ftdi pointer to ftdi_context
1036 \param chunksize Pointer to store chunk size in
1040 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1042 *chunksize = ftdi->writebuffer_chunksize;
1047 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1049 Automatically strips the two modem status bytes transfered during every read.
1051 \param ftdi pointer to ftdi_context
1052 \param buf Buffer to store data in
1053 \param size Size of the buffer
1055 \retval <0: error code from usb_bulk_read()
1056 \retval 0: no data was available
1057 \retval >0: number of bytes read
1059 \remark This function is not useful in bitbang mode.
1060 Use ftdi_read_pins() to get the current state of the pins.
1062 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1064 int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
1066 // everything we want is still in the readbuffer?
1067 if (size <= ftdi->readbuffer_remaining) {
1068 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1071 ftdi->readbuffer_remaining -= size;
1072 ftdi->readbuffer_offset += size;
1074 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1078 // something still in the readbuffer, but not enough to satisfy 'size'?
1079 if (ftdi->readbuffer_remaining != 0) {
1080 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1083 offset += ftdi->readbuffer_remaining;
1085 // do the actual USB read
1086 while (offset < size && ret > 0) {
1087 ftdi->readbuffer_remaining = 0;
1088 ftdi->readbuffer_offset = 0;
1089 /* returns how much received */
1090 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
1092 ftdi_error_return(ret, "usb bulk read failed");
1095 // skip FTDI status bytes.
1096 // Maybe stored in the future to enable modem use
1097 num_of_chunks = ret / 64;
1098 chunk_remains = ret % 64;
1099 //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1101 ftdi->readbuffer_offset += 2;
1105 for (i = 1; i < num_of_chunks; i++)
1106 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
1107 ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
1109 if (chunk_remains > 2) {
1110 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
1111 ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
1113 ret -= 2*num_of_chunks;
1115 ret -= 2*(num_of_chunks-1)+chunk_remains;
1117 } else if (ret <= 2) {
1118 // no more data to read?
1122 // data still fits in buf?
1123 if (offset+ret <= size) {
1124 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
1125 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1128 /* Did we read exactly the right amount of bytes? */
1130 //printf("read_data exact rem %d offset %d\n",
1131 //ftdi->readbuffer_remaining, offset);
1134 // only copy part of the data or size <= readbuffer_chunksize
1135 int part_size = size-offset;
1136 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1138 ftdi->readbuffer_offset += part_size;
1139 ftdi->readbuffer_remaining = ret-part_size;
1140 offset += part_size;
1142 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
1143 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
1154 Configure read buffer chunk size.
1157 Automatically reallocates the buffer.
1159 \param ftdi pointer to ftdi_context
1160 \param chunksize Chunk size
1164 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1166 unsigned char *new_buf;
1168 // Invalidate all remaining data
1169 ftdi->readbuffer_offset = 0;
1170 ftdi->readbuffer_remaining = 0;
1172 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1173 ftdi_error_return(-1, "out of memory for readbuffer");
1175 ftdi->readbuffer = new_buf;
1176 ftdi->readbuffer_chunksize = chunksize;
1182 Get read buffer chunk size.
1184 \param ftdi pointer to ftdi_context
1185 \param chunksize Pointer to store chunk size in
1189 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1191 *chunksize = ftdi->readbuffer_chunksize;
1197 Enable bitbang mode.
1199 For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
1201 \param ftdi pointer to ftdi_context
1202 \param bitmask Bitmask to configure lines.
1203 HIGH/ON value configures a line as output.
1206 \retval -1: can't enable bitbang mode
1208 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1210 unsigned short usb_val;
1212 usb_val = bitmask; // low byte: bitmask
1213 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1214 usb_val |= (ftdi->bitbang_mode << 8);
1216 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1217 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1219 ftdi->bitbang_enabled = 1;
1224 Disable bitbang mode.
1226 \param ftdi pointer to ftdi_context
1229 \retval -1: can't disable bitbang mode
1231 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1233 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1234 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1236 ftdi->bitbang_enabled = 0;
1241 Enable advanced bitbang mode for FT2232C chips.
1243 \param ftdi pointer to ftdi_context
1244 \param bitmask Bitmask to configure lines.
1245 HIGH/ON value configures a line as output.
1246 \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
1249 \retval -1: can't enable bitbang mode
1251 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1253 unsigned short usb_val;
1255 usb_val = bitmask; // low byte: bitmask
1256 usb_val |= (mode << 8);
1257 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1258 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1260 ftdi->bitbang_mode = mode;
1261 ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
1266 Directly read pin state. Useful for bitbang mode.
1268 \param ftdi pointer to ftdi_context
1269 \param pins Pointer to store pins into
1272 \retval -1: read pins failed
1274 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1276 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
1277 ftdi_error_return(-1, "read pins failed");
1285 The FTDI chip keeps data in the internal buffer for a specific
1286 amount of time if the buffer is not full yet to decrease
1287 load on the usb bus.
1289 \param ftdi pointer to ftdi_context
1290 \param latency Value between 1 and 255
1293 \retval -1: latency out of range
1294 \retval -2: unable to set latency timer
1296 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1298 unsigned short usb_val;
1301 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1304 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1305 ftdi_error_return(-2, "unable to set latency timer");
1313 \param ftdi pointer to ftdi_context
1314 \param latency Pointer to store latency value in
1317 \retval -1: unable to get latency timer
1319 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1321 unsigned short usb_val;
1322 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1323 ftdi_error_return(-1, "reading latency timer failed");
1325 *latency = (unsigned char)usb_val;
1330 Poll modem status information
1332 This function allows the retrieve the two status bytes of the device.
1333 The device sends these bytes also as a header for each read access
1334 where they are discarded by ftdi_read_data(). The chip generates
1335 the two stripped status bytes in the absence of data every 40 ms.
1337 Layout of the first byte:
1338 - B0..B3 - must be 0
1339 - B4 Clear to send (CTS)
1342 - B5 Data set ready (DTS)
1345 - B6 Ring indicator (RI)
1348 - B7 Receive line signal detect (RLSD)
1352 Layout of the second byte:
1353 - B0 Data ready (DR)
1354 - B1 Overrun error (OE)
1355 - B2 Parity error (PE)
1356 - B3 Framing error (FE)
1357 - B4 Break interrupt (BI)
1358 - B5 Transmitter holding register (THRE)
1359 - B6 Transmitter empty (TEMT)
1360 - B7 Error in RCVR FIFO
1362 \param ftdi pointer to ftdi_context
1363 \param status Pointer to store status information in. Must be two bytes.
1366 \retval -1: unable to retrieve status information
1368 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1372 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
1373 ftdi_error_return(-1, "getting modem status failed");
1375 *status = (usb_val[1] << 8) | usb_val[0];
1381 Set the special event character
1383 \param ftdi pointer to ftdi_context
1384 \param eventch Event character
1385 \param enable 0 to disable the event character, non-zero otherwise
1388 \retval -1: unable to set event character
1390 int ftdi_set_event_char(struct ftdi_context *ftdi,
1391 unsigned char eventch, unsigned char enable)
1393 unsigned short usb_val;
1399 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x06, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1400 ftdi_error_return(-1, "setting event character failed");
1408 \param ftdi pointer to ftdi_context
1409 \param errorch Error character
1410 \param enable 0 to disable the error character, non-zero otherwise
1413 \retval -1: unable to set error character
1415 int ftdi_set_error_char(struct ftdi_context *ftdi,
1416 unsigned char errorch, unsigned char enable)
1418 unsigned short usb_val;
1424 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x07, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1425 ftdi_error_return(-1, "setting error character failed");
1433 \param ftdi pointer to ftdi_context
1434 \param eeprom Pointer to ftdi_eeprom
1438 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
1440 ftdi->eeprom_size=size;
1445 Init eeprom with default values.
1447 \param eeprom Pointer to ftdi_eeprom
1449 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
1451 eeprom->vendor_id = 0x0403;
1452 eeprom->product_id = 0x6001;
1454 eeprom->self_powered = 1;
1455 eeprom->remote_wakeup = 1;
1456 eeprom->BM_type_chip = 1;
1458 eeprom->in_is_isochronous = 0;
1459 eeprom->out_is_isochronous = 0;
1460 eeprom->suspend_pull_downs = 0;
1462 eeprom->use_serial = 0;
1463 eeprom->change_usb_version = 0;
1464 eeprom->usb_version = 0x0200;
1465 eeprom->max_power = 0;
1467 eeprom->manufacturer = NULL;
1468 eeprom->product = NULL;
1469 eeprom->serial = NULL;
1471 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
1475 Build binary output from ftdi_eeprom structure.
1476 Output is suitable for ftdi_write_eeprom().
1478 \param eeprom Pointer to ftdi_eeprom
1479 \param output Buffer of 128 bytes to store eeprom image to
1481 \retval >0: used eeprom size
1482 \retval -1: eeprom size (128 bytes) exceeded by custom strings
1484 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
1487 unsigned short checksum, value;
1488 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1491 if (eeprom->manufacturer != NULL)
1492 manufacturer_size = strlen(eeprom->manufacturer);
1493 if (eeprom->product != NULL)
1494 product_size = strlen(eeprom->product);
1495 if (eeprom->serial != NULL)
1496 serial_size = strlen(eeprom->serial);
1498 size_check = eeprom->size;
1499 size_check -= 28; // 28 are always in use (fixed)
1501 // Top half of a 256byte eeprom is used just for strings and checksum
1502 // it seems that the FTDI chip will not read these strings from the lower half
1503 // Each string starts with two bytes; offset and type (0x03 for string)
1504 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1505 if(eeprom->size>=256)size_check = 120;
1506 size_check -= manufacturer_size*2;
1507 size_check -= product_size*2;
1508 size_check -= serial_size*2;
1510 // eeprom size exceeded?
1515 memset (output, 0, eeprom->size);
1517 // Addr 00: Stay 00 00
1518 // Addr 02: Vendor ID
1519 output[0x02] = eeprom->vendor_id;
1520 output[0x03] = eeprom->vendor_id >> 8;
1522 // Addr 04: Product ID
1523 output[0x04] = eeprom->product_id;
1524 output[0x05] = eeprom->product_id >> 8;
1526 // Addr 06: Device release number (0400h for BM features)
1527 output[0x06] = 0x00;
1529 if (eeprom->BM_type_chip == 1)
1530 output[0x07] = 0x04;
1532 output[0x07] = 0x02;
1534 // Addr 08: Config descriptor
1535 Â Â // Bit 7: always 1
1536 Â Â // Bit 6: 1 if this device is self powered, 0 if bus powered
1537 Â Â // Bit 5: 1 if this device uses remote wakeup
1538 Â Â // Bit 4: 1 if this device is battery powered
1540 if (eeprom->self_powered == 1)
1542 if (eeprom->remote_wakeup == 1)
1546 // Addr 09: Max power consumption: max power = value * 2 mA
1547 output[0x09] = eeprom->max_power;
1549 // Addr 0A: Chip configuration
1550 // Bit 7: 0 - reserved
1551 // Bit 6: 0 - reserved
1552 // Bit 5: 0 - reserved
1553 // Bit 4: 1 - Change USB version
1554 // Bit 3: 1 - Use the serial number string
1555 // Bit 2: 1 - Enable suspend pull downs for lower power
1556 // Bit 1: 1 - Out EndPoint is Isochronous
1557 // Bit 0: 1 - In EndPoint is Isochronous
1560 if (eeprom->in_is_isochronous == 1)
1562 if (eeprom->out_is_isochronous == 1)
1564 if (eeprom->suspend_pull_downs == 1)
1566 if (eeprom->use_serial == 1)
1568 if (eeprom->change_usb_version == 1)
1572 // Addr 0B: reserved
1573 output[0x0B] = 0x00;
1575 // Addr 0C: USB version low byte when 0x0A bit 4 is set
1576 // Addr 0D: USB version high byte when 0x0A bit 4 is set
1577 if (eeprom->change_usb_version == 1) {
1578 output[0x0C] = eeprom->usb_version;
1579 output[0x0D] = eeprom->usb_version >> 8;
1583 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
1584 // Addr 0F: Length of manufacturer string
1585 output[0x0F] = manufacturer_size*2 + 2;
1587 // Addr 10: Offset of the product string + 0x80, calculated later
1588 // Addr 11: Length of product string
1589 output[0x11] = product_size*2 + 2;
1591 // Addr 12: Offset of the serial string + 0x80, calculated later
1592 // Addr 13: Length of serial string
1593 output[0x13] = serial_size*2 + 2;
1597 if(eeprom->size>=256) i = 0x80;
1600 // Output manufacturer
1601 output[0x0E] = i | 0x80; // calculate offset
1602 output[i++] = manufacturer_size*2 + 2;
1603 output[i++] = 0x03; // type: string
1604 for (j = 0; j < manufacturer_size; j++) {
1605 output[i] = eeprom->manufacturer[j], i++;
1606 output[i] = 0x00, i++;
1609 // Output product name
1610 output[0x10] = i | 0x80; // calculate offset
1611 output[i] = product_size*2 + 2, i++;
1612 output[i] = 0x03, i++;
1613 for (j = 0; j < product_size; j++) {
1614 output[i] = eeprom->product[j], i++;
1615 output[i] = 0x00, i++;
1619 output[0x12] = i | 0x80; // calculate offset
1620 output[i] = serial_size*2 + 2, i++;
1621 output[i] = 0x03, i++;
1622 for (j = 0; j < serial_size; j++) {
1623 output[i] = eeprom->serial[j], i++;
1624 output[i] = 0x00, i++;
1627 // calculate checksum
1630 for (i = 0; i < eeprom->size/2-1; i++) {
1631 value = output[i*2];
1632 value += output[(i*2)+1] << 8;
1634 checksum = value^checksum;
1635 checksum = (checksum << 1) | (checksum >> 15);
1638 output[eeprom->size-2] = checksum;
1639 output[eeprom->size-1] = checksum >> 8;
1647 \param ftdi pointer to ftdi_context
1648 \param eeprom Pointer to store eeprom into
1651 \retval -1: read failed
1653 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
1657 for (i = 0; i < ftdi->eeprom_size/2; i++) {
1658 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
1659 ftdi_error_return(-1, "reading eeprom failed");
1666 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
1667 Function is only used internally
1670 static unsigned char ftdi_read_chipid_shift(unsigned char value)
1672 return ((value & 1) << 1) |
1673 ((value & 2) << 5) |
1674 ((value & 4) >> 2) |
1675 ((value & 8) << 4) |
1676 ((value & 16) >> 1) |
1677 ((value & 32) >> 1) |
1678 ((value & 64) >> 4) |
1679 ((value & 128) >> 2);
1683 Read the FTDIChip-ID from R-type devices
1685 \param ftdi pointer to ftdi_context
1686 \param chipid Pointer to store FTDIChip-ID
1689 \retval -1: read failed
1691 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
1693 unsigned int a = 0, b = 0;
1695 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
1697 a = a << 8 | a >> 8;
1698 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
1700 b = b << 8 | b >> 8;
1702 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
1703 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
1704 *chipid = a ^ 0xa5f0f7d1;
1709 ftdi_error_return(-1, "read of FTDIChip-ID failed");
1713 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
1714 Call this function then do a write then call again to see if size changes, if so write again.
1716 \param ftdi pointer to ftdi_context
1717 \param eeprom Pointer to store eeprom into
1718 \param maxsize the size of the buffer to read into
1720 \retval size of eeprom
1722 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
1724 int i=0,j,minsize=32;
1728 for (j = 0; i < maxsize/2 && j<size; j++) {
1729 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
1730 ftdi_error_return(-1, "reading eeprom failed");
1734 }while(size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
1742 \param ftdi pointer to ftdi_context
1743 \param eeprom Pointer to read eeprom from
1746 \retval -1: read failed
1748 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
1750 unsigned short usb_val;
1753 for (i = 0; i < ftdi->eeprom_size/2; i++) {
1754 usb_val = eeprom[i*2];
1755 usb_val += eeprom[(i*2)+1] << 8;
1756 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0)
1757 ftdi_error_return(-1, "unable to write eeprom");
1766 \param ftdi pointer to ftdi_context
1769 \retval -1: erase failed
1771 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
1773 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
1774 ftdi_error_return(-1, "unable to erase eeprom");
1780 Get string representation for last error code
1782 \param ftdi pointer to ftdi_context
1784 \retval Pointer to error string
1786 char *ftdi_get_error_string (struct ftdi_context *ftdi)
1788 return ftdi->error_str;
1792 Flow control code by Lorenz Moesenlechner (lorenz@hcilab.org)
1793 and Matthias Kranz (matthias@hcilab.org)
1796 Set flowcontrol for ftdi chip
1798 \param ftdi pointer to ftdi_context
1799 \param flowctrl flow control to use. should be
1800 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1803 \retval -1: set flow control failed
1805 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1807 if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1808 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->interface),
1809 NULL, 0, ftdi->usb_write_timeout) != 0)
1810 ftdi_error_return(-1, "set flow control failed");
1818 \param ftdi pointer to ftdi_context
1819 \param state state to set line to (1 or 0)
1822 \retval -1: set dtr failed
1824 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1826 unsigned short usb_val;
1829 usb_val = SIO_SET_DTR_HIGH;
1831 usb_val = SIO_SET_DTR_LOW;
1833 if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1834 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
1835 NULL, 0, ftdi->usb_write_timeout) != 0)
1836 ftdi_error_return(-1, "set dtr failed");
1844 \param ftdi pointer to ftdi_context
1845 \param state state to set line to (1 or 0)
1848 \retval -1 set rts failed
1850 int ftdi_setrts(struct ftdi_context *ftdi, int state)
1852 unsigned short usb_val;
1855 usb_val = SIO_SET_RTS_HIGH;
1857 usb_val = SIO_SET_RTS_LOW;
1859 if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1860 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
1861 NULL, 0, ftdi->usb_write_timeout) != 0)
1862 ftdi_error_return(-1, "set of rts failed");
1867 /* @} end of doxygen libftdi group */